How to Use Docker Desktop for Local Development

Edited 1 week ago by ExtremeHow Editorial Team

Docker DesktopDevelopmentUsageSoftware DevelopmentDevOpsLocal EnvironmentCloud ComputingVirtualizationProductivityWorkflow

Local development refers to the process of writing and testing your code on your local machine before deploying it to a production server. Docker Desktop is a useful tool that allows developers to run containerized applications locally, making the process of local development more efficient, scalable, and manageable. This document provides a detailed guide on how to use Docker Desktop for local development, even if you are new to these concepts. By the end of the guide, you should have a clear understanding of Docker, Docker Desktop, and how to use them effectively in your local development workflow. Let's get started.

Understanding Docker and Docker Desktop

Before diving into Docker Desktop, it's important to understand what Docker is. Docker is a platform that allows you to develop, ship, and run applications in containers. Containers allow you to package an application with all of its dependencies and configuration into a single unit that can run consistently across different environments. This consistency ensures that the application behaves the same during development, testing, and production.

Docker Desktop is an application for building and sharing containerized applications and microservices for MacOS and Windows machines. Docker Desktop includes Docker Engine, Docker CLI Client, Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. It is a comprehensive solution for developers who need to build, manage, and deploy containerized applications locally. With Docker Desktop, you get a straightforward interface and a rich set of tools for managing containers, making it a preferred choice for developers working on local projects.

Setting up Docker Desktop

Installation

First, you need to install Docker Desktop on your machine. Follow these steps:

1. Visit the official Docker Desktop page.
2. Download the appropriate installer for your operating system (Windows or Mac).
3. Run the installer and follow the on-screen instructions. The installer will ask for administrative permissions, so make sure you have them.
4. Once the installation is complete, Docker Desktop will start automatically, or you can start it manually from your Applications menu.
5. To verify the installation, open a terminal window (or command prompt on Windows), and type the command: docker --version. This should display the version of Docker if it is installed correctly.

Layout

After installation, you may need to do some initial configuration:

• Docker Hub login: If you have a Docker Hub account, you can log in directly from Docker Desktop to pull images from the repository.
• Configuration and resources: Navigate to Docker Desktop Settings to configure the resources allocated to Docker, such as CPU, memory, disk space, and network settings.
• Kubernetes: Docker Desktop includes the option to run the container orchestration platform Kubernetes, which can be enabled in the settings if required.

Using Docker Desktop for local development

Creating Dockerfiles

Every container you run in Docker is built using a Dockerfile. A Dockerfile is a plain-text file that contains instructions for building a Docker image. Here is a basic example of a Dockerfile for a simple Python application:

# Use an official Python runtime as the parent image FROM python:3.8-slim # Set the working directory WORKDIR /app # Copy the current directory contents into the container at /app COPY . /app # Install any needed packages specified in requirements.txt RUN pip install --no-cache-dir -r requirements.txt # Make port 80 available to the world outside this container EXPOSE 80 # Run app.py when the container launches CMD ["python", "app.py"]
# Use an official Python runtime as the parent image FROM python:3.8-slim # Set the working directory WORKDIR /app # Copy the current directory contents into the container at /app COPY . /app # Install any needed packages specified in requirements.txt RUN pip install --no-cache-dir -r requirements.txt # Make port 80 available to the world outside this container EXPOSE 80 # Run app.py when the container launches CMD ["python", "app.py"]

This Dockerfile performs the following tasks:

• FROM python:3.8-slim: This tells Docker to use the Python 3.8 slim image as the base image.
• WORKDIR /app: This sets the working directory inside the container to /app.
• COPY . /app: This copies the current directory contents (your app's files) into the container.
• RUN pip install --no-cache-dir -r requirements.txt: This installs the required Python packages listed in the requirements.txt file.
• EXPOSE 80: This allows the application to communicate through port 80.
• CMD ["python", "app.py"]: This specifies the command to run when the container starts.

Creating Docker images

Once you have a Dockerfile, you can build a Docker image. Go to the directory containing your Dockerfile in the terminal and execute the following command:

 docker build -t my-python-app .

The detailed description of this order is as follows:

• docker build is the command to build a Docker image from a Dockerfile.
• -t my-python-app tags the image with a name, in this case, "my-python-app".
• . Specifies the build context location, which is the current directory.

Running a Docker container

After building your image, you can run it as a container. Use the following command to start a container from your image:

 docker run -d -p 4000:80 my-python-app

Explanation of this command:

• docker run executes the command to start a new container.
• -d Runs the container in isolated mode (in the background).
• -p 4000:80 maps port 4000 on your host to port 80 in the container, allowing you to access the application at localhost:4000.
• my-python-app refers to the Docker image you created earlier.

Docker Compose

When working on local development, especially with applications that consist of multiple services or microservices, the process of managing these services can be simplified using Docker Compose. Docker Compose is a tool for defining and running multi-container Docker applications. Here is an example of docker-compose.yml file:

version: '3' services: web: image: my-python-app ports: - "4000:80" database: image: postgres environment: POSTGRES_USER: example POSTGRES_PASSWORD: example
version: '3' services: web: image: my-python-app ports: - "4000:80" database: image: postgres environment: POSTGRES_USER: example POSTGRES_PASSWORD: example

in this instance:

• The web service is created from my-python-app image you built, and it maps port 4000 on the host to port 80 in the container.
• The database service uses the PostgreSQL image and sets environment variables for the default user and password.

To start your multi-container application specified in docker-compose.yml, execute the following command in the terminal:

 docker-compose up

This command creates, (re)creates, starts, and attaches containers to a service. You can stop the application using docker-compose down, which will stop and remove containers.

Managing Docker containers

Once your containers are running, you may need to perform a variety of management tasks. Here are some common commands:

• docker ps: Lists all running containers.
• docker stop <container-id>: Stops a running container using its ID.
• docker start <container-id>: Starts a stopped container using its ID.
• docker logs <container-id>: Displays the logs of the container, which is useful for debugging.
• docker exec -it <container-id> /bin/bash: Opens a shell instance inside a running container, allowing you to manually inspect and interact with it.
• docker rm <container-id>: Removes a stopped container from your system.
• docker rmi <image-id>: Removes the image from your system, freeing up disk space.

Sending to Docker Hub

If you want to share your Docker images with others or use them on other systems, you can push them to Docker Hub, a cloud-based repository. Here's how you can do it:

1. Log into Docker Hub from your terminal using docker login.
2. Tag your local image to prepare it for upload: docker tag my-python-app <your-username>/my-python-app.
3. Push the image: docker push <your-username>/my-python-app.

Once pushed, your image will be available in your Docker Hub account, and you can pull it to other machines using docker pull <your-username>/my-python-app.

Best practices for using Docker Desktop

Version control for Dockerfiles

Always include your Dockerfiles in your version control system. This ensures that the exact configuration of the container environment is tracked with the source code of your application. This practice will help anyone working on your application, including you in the future, easily create environments.

Keep Docker images small

Large Docker images take more time to build, transfer, and run. Therefore, reducing the image size is very important for efficiency. You can reduce the image size by:

• Starting with a minimal base image and installing only the necessary dependencies.
• Clearing temporary files and cache during the image creation process.
• Using multi-stage builds to separate build dependencies from run-time artifacts.

Here's an example of a multi-stage Dockerfile:

# Build stage FROM golang:1.15 as builder WORKDIR /app COPY . . RUN go build -o myapp # Final stage FROM alpine:latest WORKDIR /app COPY --from=builder /app/myapp . ENTRYPOINT ["./myapp"]
# Build stage FROM golang:1.15 as builder WORKDIR /app COPY . . RUN go build -o myapp # Final stage FROM alpine:latest WORKDIR /app COPY --from=builder /app/myapp . ENTRYPOINT ["./myapp"]

Security considerations

Security should not be overlooked when working with Docker. Here are some practices to enhance security:

• Running containers with the minimum required privileges using USER directive in the Dockerfile.
• Regularly updating base images to include security patches.
• Using official or trusted images from Docker Hub.
• Setting network rules that limit access to your containers.

Monitoring and logging

Establish a logging and monitoring system for your Docker environment. Consider using tools like Docker's native logging driver, Prometheus for metrics, and Grafana for beautiful data visualizations. With proper monitoring, you'll get insight into the behavior and performance of your containers, allowing you to react quickly to any problems.

Conclusion

Docker Desktop is an essential tool for developers who want to take advantage of container technology on their local development machines. By allowing applications to run in separate containers, Docker Desktop simplifies the setup and management of development environments. It increases stability and reduces the problem of making sure it works on my machine by packaging everything needed to run the application together.

This guide provides a detailed overview of Docker Desktop, from installation and configuration to creating and running containers and best practices for using Docker in local development. By integrating Docker Desktop into your development processes, you gain a powerful ally in building, testing, and deploying robust applications more efficiently.

As with any technology, the key to mastering Docker, and by extension Docker Desktop, is consistent practice and continuous learning. The more you apply these principles and explore the vast ecosystem of Docker tools and resources, the more proficient you will become.

  Share This Article

If you find anything wrong with the article content, you can request an update