A Zero To Hero Guide on Docker (with project)

Introduction

Hello and welcome to this blog post where I will show you how to get started with Docker, one of the most popular and powerful tools for creating and managing containers. If you are new to containers, they are a way of packaging your applications and their dependencies into isolated and portable units that can run on any platform. Docker makes it easy to build, run, and share containers with others.

In this post, I will cover the following topics:

What is Docker and why you should use it
How to install Docker on your machine
How to create your first Docker image and container
How to use Docker commands and options
How to push and pull images from Docker Hub
How to use Docker Compose to orchestrate multiple containers

By the end of this post, you will have a solid understanding of the basics of Docker and how to use it for your own projects. So let's get started!

If you are a developer, you have probably heard of Docker, but you may not know what it is or why you should use it. In this blog post, I will explain what Docker is and how it can help you create, deploy and run your applications more easily and efficiently.

What is Docker?

Docker is a software platform that allows you to build, test and run applications using containers. Containers are isolated environments that contain everything your application needs to run: code, libraries, dependencies, configuration files, etc. Containers are lightweight and portable, which means you can run them on any machine that has Docker installed, regardless of the operating system or hardware.

Why should you use Docker?

Here are some of the benefits of using Docker for your development and deployment process:

Consistency: With Docker, you can ensure that your application runs the same way on any machine, whether it is your laptop, a colleague's computer or a cloud server. You don't have to worry about compatibility issues or configuration errors that can cause bugs or delays.
Reproducibility: With Docker, you can easily recreate the exact state of your application at any point in time. You can also share your containers with other developers or users, so they can run your application without any hassle.
Efficiency: With Docker, you can make the most of your resources. Containers are much faster and lighter than virtual machines, which means you can run more applications on the same hardware. You can also reuse existing containers for different purposes, which reduces the time and effort required to create new ones.
Security: With Docker, you can isolate your application from the host system and other applications. This reduces the risk of malicious attacks or accidental interference. You can also apply security policies and updates to your containers without affecting the rest of your system.

As you can see, Docker is a powerful tool that can help you develop and deploy your applications faster and easier. If you want to learn more about Docker and how to use it, check out the official documentation at https://docs.docker.com/. You can also find many tutorials and courses online that will teach you how to use Docker for various projects and scenarios.

How to install Docker on your machine

Check if your machine meets the requirements for Docker. You need to have a 64-bit processor with at least 4 GB of RAM and a compatible operating system. Docker supports Windows 10 Pro or Enterprise, macOS Catalina or newer, and various Linux distributions such as Ubuntu, Debian, Fedora, and CentOS. If you're not sure what you have, you can use the following commands to find out:

" On Windows, open PowerShell and type systeminfo

On macOS, open Terminal and type sw_vers

On Linux, open Terminal and type uname -a and free -m "
Download the Docker Desktop installer from the official website: https://www.docker.com/products/docker-desktop. Choose the version that matches your operating system and follow the instructions on the screen. The installer will guide you through the installation process and ask you to accept the license agreement and choose some settings. You may need to restart your machine after the installation is complete.
Verify that Docker is installed and running correctly. You can do this by opening a terminal window and typing docker version. You should see some information about the Docker client and server (also called the Docker Engine). If you see an error message instead, try to troubleshoot it by checking the Docker documentation or searching online for a solution.

Congratulations! You have successfully installed Docker on your machine. Now you can start creating and running containers with Docker commands or using the Docker Desktop app. You can also explore the Docker Hub, which is a repository of pre-built images that you can use to run various applications and services.

For example, you can run a WordPress site with this command: docker run -d -p 80:80 wordpress. Have fun with Docker!

How to create your first Docker image and container

A Docker image is a file that contains all the information and dependencies needed to run an application. A Docker container is an instance of a Docker image that can be executed on a host machine. You can create your own Docker images using a Dockerfile, which is a text file that specifies the instructions for building the image.

Once you have installed Docker, you can create a simple Dockerfile that will run a Python script that prints "Hello, world!" to the standard output. The Dockerfile will look something like this.

# Use the official Python image as the base image
FROM python:3.9

# Copy the script file to the working directory
COPY hello.py .

# Run the script when the container starts
CMD ["python3", "hello.py"]

Save this file as Dockerfile in a folder of your choice. Then, create another file named hello.py in the same folder with the following content:

# Print a message to the standard output
print("Hello, world!")

Now, you are ready to build your Docker image using the docker build command. Navigate to the folder where you saved the files and run the following command:

docker build -t hello-world .

Yayy !! You now have a docker image.

To run your image as a container, you can use the docker run command. Run the following command:

docker run hello-world

This command will create and start a container from your hello-world image and execute the script inside it. You should see the following output:

Hello, World!

Congratulations! You have successfully created and run your first Docker image and container. You can stop and remove the container by pressing Ctrl+C on your terminal.

You can run multiple containers on the same machine without worrying about conflicts or dependencies.

You can also use pre-built images from Docker Hub, which is a public registry that hosts thousands of images for various applications and languages. You can also push your own images to Docker Hub or use private registries to store and share your images.

To learn more about Docker and how to use it for more complex applications, you can check out the official documentation here: https://docs.docker.com/

How to use Docker commands and options

The docker run command has many options that you can use to customize the behaviour of your container. For example,

You can use the -d option to run the container in detached mode, which means that it will run in the background and return control to your terminal.
You can use the -p option to map ports between the container and the host, which allows you to access network services running in the container.
You can use the -v option to mount volumes between the container and the host, which allows you to persist data or share files between them.
You can use the -e option to set environment variables in the container, which can be used to configure your application or pass parameters to it.
You can use the --name option to give a name to your container, which makes it easier to identify and refer to it later.

For example, if you want to run a web server in a container using the nginx image, you can use this command:

docker run -d -p 80:80 --name web nignx

This command will create a new container named web, run it in detached mode, map port 80 of the host to port 80 of the container, and use the nginx image as the base. You should be able to access the web server by visiting http://localhost on your browser.

To manage your containers, you can use other commands such as docker ps, docker stop, docker start, docker rm, docker logs, docker exec, etc. These commands allow you to list, stop, start, remove, view logs, and execute commands in your containers. For example, if you want to see all the running containers on your system, you can use this command:

docker ps

This command will show you information such as the container ID, name, image, status, ports, etc. You can use these identifiers to refer to your containers in other commands.

How to push and pull images from Docker Hub

I will show you how to push and pull images from Docker Hub, the world's largest library and community for container images. Docker Hub is a great place to find and share images for your applications, whether you are a beginner or an expert. You can also use Docker Hub to store and manage your own images in private or public repositories. Let's get started!

First, you need to have a Docker account and be logged in to Docker Hub. You can create an account for free at https://hub.docker.com/. Once you have an account, you can log in to Docker Hub using the docker login command in your terminal. You will be prompted to enter your username and password.

Next, you need to have an image that you want to push or pull. An image is a read-only template that contains the instructions for creating a container. You can create your own image using a Dockerfile, or you can use an existing image from Docker Hub or another source.

For this tutorial, I will use a simple image that prints "Hello, world!" when run. You can find the image on Docker Hub at https://hub.docker.com/r/library/hello-world.

To pull an image from Docker Hub, you use the docker pull command followed by the name of the image. For example, to pull the hello-world image, you would type:

docker pull hello-world

This will download the image to your local machine. You can verify that the image is available by using the docker images command, which lists all the images on your machine. You should see something like this:


REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest d1165f221234 2 months ago 13.3kB

To run the image, you use the docker run command followed by the name of the image. For example, to run the hello-world image, you would type:

docker run hello-world

This will create and start a container from the image and print the following message:

Hello from Docker!

This message shows that your installation appears to be working correctly.

To push an image to Docker Hub, you need to tag it with your username and a name for the repository. A repository is a collection of images with the same name but different tags. For example, if your username is abhishek, and you want to create a repository called my-app, you would tag your image as abhishek/my-app. You can use any name for the repository, as long as it is not already taken by someone else on Docker Hub.

To tag an image, you use the docker tag command followed by the name of the image and the new tag. For example, if you have an image called my-image that you want to tag as abhishek/my-app, you would type:

docker tag my-image abhishek/my-app

This will create a new tag for the image, but it will not delete the original one. You can verify that the tag was created by using the docker images command again. You should see something like this:

REPOSITORY TAG IMAGE ID CREATED SIZE
abhishek/my-app latest d1165f221234 2 months ago 13.3kB
my-image latest d1165f221234 2 months ago 13.3kB
hello-world latest d1165f221234 2 months ago 13.3kB

Notice that both abhishek/my-app and my-image have the same image ID, which means they are pointing to the same image.

To push an image to Docker Hub, you use the docker push command followed by the name of the tag. For example, to push the abhishek/my-app tag to Docker Hub, you would type:

docker push abhishek/my-app

This will upload the image to your repository on Docker Hub.

Congratulations! You have successfully pushed and pulled images from Docker Hub! You can now use these images for your applications or share them with others. If you have any questions or feedback, please leave a comment below.

How to use Docker Compose to orchestrate multiple containers

If you are working on a project that involves multiple technologies, such as MySQL, Python, NodeJS, and .NET, you might want to use Docker Compose to orchestrate multiple containers. Docker Compose is a tool that lets you define and run multiple containers with a single YAML file. In this blog post, I will show you how to use Docker Compose to deploy a multi-container application locally and then on Azure Container Instances.

First, you need to create a Dockerfile for each project. A Dockerfile is a file that contains instructions for building a container image. For example, here is a Dockerfile for a Python app that uses Flask and requests libraries:

FROM python:3.9 
WORKDIR /app 
COPY requirements.txt . 
RUN pip install -r requirements.txt 
COPY app.py . 
CMD ["python", "app.py"]

Next, you need to create a docker-compose.yml file in the root folder of your project. This file will contain the configuration for all the services that make up your application. For example, here is a docker-compose.yml file for an application that uses MySQL, Python, NodeJS, and .NET:

version: '3.4'
services:
  db:
    image: mysql:8.0.28
    environment:
      MYSQL_DATABASE: 'super-app'
      MYSQL_ROOT_PASSWORD: '$SuperApp1'
    ports:
      - '3306:3306'
    expose:
      - '3306'
  python:
    build: ./python
    depends_on:
      - db
    ports:
      - '5000:5000'
  node:
    build: ./node
    depends_on:
      - db
    ports:
      - '3000:3000'
  dotnet:
    build: ./dotnet
    depends_on:
      - db
    ports:
      - '8000:8000'

As you can see, each service has a name, an image or a build context, and some optional parameters such as environment variables, ports, and dependencies. You can also use volumes, networks, secrets, and other features of Docker Compose to customize your configuration.

To run your application locally, you can use the docker-compose up command in the terminal. This will build and start all the containers according to your docker-compose.yml file. You can then access your application from your browser using the ports specified in the file.

To deploy your application on Azure Container Instances, you need to create an Azure container registry and push your images there. You also need to create an Azure context and use it with docker-compose up command. For more details on how to do this, you can follow this tutorial: https://learn.microsoft.com/en-us/azure/container-instances/tutorial-docker-compose

Docker Compose is a powerful tool that simplifies the development and deployment of multi-container applications. I hope this blog post has helped you understand how to use it with different technologies.

Helpful Community

If I was able to teach you a thing or two from this blog and you enjoyed reading it consider sharing this blog with your friends and leave your valuable feedback and comments down below. I am Abhishek a student of Giganoto Batch-1 and If you think I added some value to you. Consider Checking out this amazing community called Khera Shanu.

https://discord.gg/gS5yU8yh7a

Abhishek