Docker is a tool that helps developers package their applications and everything they need to run into a container, making it easy to distribute and run on different environments. To make this process even more efficient, there are container registries that allow developers to store and manage their container images.

A Docker image is a lightweight, standalone package that contains everything needed to run an application. To build a Docker image, you need to create a Dockerfile that specifies the base image, any additional dependencies, and the commands to install and configure the application.

To build the Docker image, you can use the “docker build” command, which takes the path to the Dockerfile and uses it to build the image. The command reads the Dockerfile, downloads any dependencies that are needed, and then uses the given configuration to make an image. The resulting image can then be used to run containers.

Here are the basic steps to build a Docker image:

Create a Dockerfile with the necessary configuration for your application.
Navigate to the directory containing the Dockerfile in your terminal.
Run the “docker build” command, specifying the path to the Dockerfile and a name for the image.
Wait for the build process to complete, which may take some time depending on the size of the application and the number of dependencies.
Verify that the image was built successfully by running the “docker images” command, which should list all the Docker images available on your system.

Before you dive into this blog, let me tell you about other articles that you might find helpful. If you haven’t read our previous piece on Docker, you might want to give it a quick scan first.

Why, you ask? Well, understanding the basics of Docker can really help you grasp the commands and their importance. Think of it like building a house — you need a strong foundation before you start building the walls.

Data Engineering — Basic Introduction

Demystifying virtualization, containerization, and Docker architecture

Essential Docker Commands You Should Know

Dockerfile

Dockerfile is a text file that contains a set of instructions to build a Docker image. It is a simple and efficient way to create a Docker image. The Dockerfile concept is based on the idea of layers. Each instruction in the Dockerfile creates a new layer, and the layers are stacked on top of each other to create the final Docker image. The Dockerfile includes instructions to install software packages, copy files, set environment variables, and configure the container.

A Dockerfile is a simple text file with instructions and arguments. Docker can build images automatically by reading the instructions given in a Dockerfile

In this section, we’ll walk through the steps to build and push a Docker image to a container registry using a simple HTML program as an example. We’ll use Docker Hub as our container registry, but the process is similar for other registries like Google Container Registry, Amazon ECR, and Azure Container Registry.

Step 1: Install Docker

Before you begin, make sure you have Docker installed on your machine. You can download Docker Desktop for Windows or Mac from the official website, or install Docker Engine on Linux using the official documentation.

Step 2: Create a simple HTML file

Create a new directory for your project, and create an index.html file with the following content:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Simple HTML App</title>
</head>
<body>
    <h1>Hello, Docker!</h1>
    <p>This is a simple HTML app running inside a Docker container.</p>
</body>
</html>

Step 3: Create a Dockerfile

In the same directory as your index.html file, create a new file called Dockerfile with the following content:

# Use the official Nginx image as the base image
FROM nginx:stable-alpine

# Copy the HTML file to the Nginx default directory
COPY Index.html /usr/share/nginx/html/

#This Dockerfile specifies that we want to use the official Nginx image as our base image and copy our index.html file to the default directory served by Nginx.

This Dockerfile specifies that we want to use the official Nginx image as our base image and copy our index.html file to the default directory served by Nginx.

Why do we need to choose a base image while creating a Docker file?

Choosing a base image while creating a Dockerfile is important because it provides a starting point for building the container image. A base image is an existing image that already contains an operating system, runtime environment, and pre-installed software packages.

By using a base image, you don’t have to start from scratch and install all the dependencies yourself. This can save you a lot of time and effort, especially if you are building complex applications that require a lot of dependencies.

For example, if you are building a web application using Node.js, you can choose a base image that already has Node.js installed. This image can also include other dependencies such as npm, so you don’t have to install them manually.

Choosing a base image that is maintained by a reputable source (such as Docker Hub) can also help ensure that the image is secure and up-to-date with the latest security patches.

Overall, choosing the right base image is important to ensure that your Docker image is efficient, secure, and easy to maintain

Step 4: Build the Docker image

Open a terminal or command prompt, navigate to the directory containing your index.html file and Dockerfile, and run the following command:

docker build -t your-dockerhub-username/my-simple-html-app:latest .

docker build -t your-dockerhub-username/my-simple-html-app:latest .

Replace your-dockerhub-username with your actual Docker Hub username. This command builds the Docker image and tags it with the latest tag.

NOTE: How to avoid the Below Error

To fix the error, you need to specify the path to the Dockerfile in the docker build command. The corrected command would be:

docker build -t rajvivan/my-simple-html-app:latest .

docker build -t rajvivan/my-simple-html-app:latest .

Here, . indicates the current directory and Dockerfile should be present in this directory. If the Dockerfile is present in a different directory, replace . it with the path to that directory.

Step 5: Create a Docker Hub account and repository

If you haven’t already, create a Docker Hub account(Docker Hub ). Once you’ve signed up, create a new repository by clicking on the “Create Repository” button. Name the repository my-simple-html-app, and choose the visibility (public or private).

Step 6: Log in to Docker Hub

In your terminal, run the following command to log in to Docker Hub:

docker login

Enter your Docker Hub username and password when prompted.

Step 7: Push the Docker image to Docker Hub

Now that you’ve logged in, push the Docker image to your Docker Hub repository using the following command:

docker push your-dockerhub-username/my-simple-html-app:latest

Again, replace your-dockerhub-username with your actual Docker Hub username.

That’s it! You’ve successfully built and pushed a Docker image containing a simple HTML program to a container registry (Docker Hub). You can now use this image to deploy your application to various platforms that support Docker containers.

Let’s take another simple example where we will be exposing the container to listen to Port 80

FROM ubuntu:18.04  
LABEL maintainer="[email protected]" 
RUN  apt-get -y update && apt-get -y install nginx
COPY default /etc/nginx/sites-available/default
COPY index.html /usr/share/nginx/html/
EXPOSE 80
CMD ["/usr/sbin/nginx", "-g", "daemon off;"]

FROM ubuntu:18.04: Specifies the base image for the container, which is Ubuntu 18.04.
LABEL maintainer="[email protected]": Adds a label to the image that specifies the maintainer's contact email address.
RUN apt-get -y update && apt-get -y install nginx: Runs two commands within the container - the first updates the package index, and the second installs the Nginx web server package.
COPY default /etc/nginx/sites-available/default: Copies a configuration file for Nginx from the host machine's default path to the container's /etc/nginx/sites-available/default path.
COPY index.html /usr/share/nginx/html/: Copies an HTML file from the host machine's index.html path to the container's /usr/share/nginx/html/ path.
EXPOSE 80: Informs Docker that the container will listen on port 80 at runtime.
CMD ["/usr/sbin/nginx", "-g", "daemon off;"]: Specifies the command to run when the container starts - this starts Nginx and runs it in the foreground as the container's main process.

The next step is to create a file name default

vi default

Copy the following contents to the default file.

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    
    root /usr/share/nginx/html;
    index index.html index.htm;

    server_name _;
    location / {
        try_files $uri $uri/ =404;
    }
}

The default file you provided is a configuration file for the NGINX web server that is used as the default configuration when creating a Docker image.

The file specifies that NGINX should listen on port 80 for both IPv4 and IPv6 connections. It also sets the root directory for the web server to “/usr/share/nginx/html” and specifies “index.html” and “index.htm” as the default files to serve when a client requests the root directory.

The “servername ;” directive specifies that this server block should match all server names (i.e., it is a catch-all server block), while the “location /” block directs all requests to try to find a matching file in the root directory specified earlier, and if no file is found, return a 404 error.

This default file is often used as a starting point for creating custom NGINX configurations for Docker images, as it provides a basic configuration that can be modified to fit the specific needs of the application being containerized.

Now Build the image

docker build -t nginx:1.0 .

-t is for tagging the image.
nginx is the name of the image.
1.0 is the tag name. If you don’t add any tag, it defaults to the tag named latest.
. means, we are referring to the Dockerfile location as the docker build context.

docker run -d -p 9090:80 --name webserver nginx:1.0

-d flag is for running the container in detached mode
-p flag for the port number, the format is local-port:container-port
--name for the container name, web server in our case

Dockerfile Best Practices:

Keep your Docker images small: Use multi-stage builds, remove unnecessary files and dependencies, and use slim base images to keep your image size small.
Use a .dockerignore file: Exclude files and directories that are not needed in the Docker image using a .dockerignore file. This will reduce the build context and speed up the build process.
Use official images: Use official images from Docker Hub as they are regularly updated and maintained. Avoid using images from unknown sources.
Use environment variables: Set environment variables in your Dockerfile to make your application more configurable and easier to manage.
Use a consistent naming convention: Use a consistent naming convention for your Docker images and tags to make it easier to manage and identify them.

Possible Docker build issues:

Slow build times: If your Docker build is taking a long time, it could be due to a large build context, inefficient Dockerfile, or slow network speeds.
Build failures: Docker builds can fail due to syntax errors in the Dockerfile, missing dependencies, or issues with the network connection.
Security vulnerabilities: Docker images can contain security vulnerabilities that can be exploited by attackers. Make sure to use official images and keep your images up-to-date with security patches.
Large image sizes: Docker images can become large if they include unnecessary files, dependencies, or layers. This can impact the performance of your application and make it harder to manage.
Compatibility issues: Docker images built on one machine may not be compatible with another machine due to differences in operating systems or dependencies. Make sure to test your Docker images on different machines to ensure compatibility.

In a nutshell,

To create a Docker image, you first need to create a Dockerfile. A Dockerfile is a script that specifies the steps needed to build the image. It contains instructions to specify the base image, any additional dependencies required, and the commands to install and configure the application.

Once you have created a Dockerfile, you can use the “docker build” command to build the image. The “docker build” command takes the path to the Dockerfile and uses it to build the image. The command first reads the Dockerfile, then downloads any necessary dependencies, and finally creates an image from the specified configuration.

After building the image, you can use the “docker run” command to start a container from the image. When you run the container, it will include all of the dependencies and configurations that you specified in the Dockerfile.

Now, to make the process of deploying Docker images even more efficient, container registries have been introduced. A container registry is essentially a server that allows developers to store and manage their container images.

Instead of manually distributing Docker images to different environments, developers can simply push their Docker images to a container registry. Other developers or deployment tools can then pull the Docker image from the registry and deploy it to their environment. This helps to make the deployment process more efficient, consistent, and scalable.

In summary, Docker helps to streamline the process of containerizing and deploying applications. It provides a standardized way to package applications with their dependencies and runtime environment into a container. Dockerfiles are used to specify the configuration of the container, and the “docker build” command is used to create the Docker image from the Dockerfile. Container registries have also been introduced to make the deployment process more efficient and scalable.

Let me give you a trick to remember the Docker commands:

For Running Effective Container Operations, Choose EXcellent tools.

The first letter of each word spells out “FRECOE”, which corresponds to the Docker commands in the following order: FROM, RUN, ENV, COPY, RUN, CMD, and EXPOSE.

Useful Docker Instructions

Let’s take another simple example where we will expose the container to listen to Port 80


FROM ubuntu:18.04  
LABEL maintainer="[email protected]" 
RUN  apt-get -y update && apt-get -y install nginx
COPY default /etc/nginx/sites-available/default
COPY index.html /usr/share/nginx/html/
EXPOSE 80
CMD ["/usr/sbin/nginx", "-g", "daemon off;"]

FROM ubuntu:18.04: Specifies the base image for the container, which is Ubuntu 18.04.
LABEL maintainer="[email protected]": Adds a label to the image that specifies the maintainer's contact email address.
RUN apt-get -y update && apt-get -y install nginx: Runs two commands within the container - the first updates the package index, and the second installs the Nginx web server package.
COPY default /etc/nginx/sites-available/default: Copies a configuration file for Nginx from the host machine's default path to the container's /etc/nginx/sites-available/default path.
COPY index.html /usr/share/nginx/html/: Copies an HTML file from the host machine's index.html path to the container's /usr/share/nginx/html/ path.
EXPOSE 80: Informs Docker that the container will listen on port 80 at runtime.
CMD ["/usr/sbin/nginx", "-g", "daemon off;"]: Specifies the command to run when the container starts - this starts Nginx and runs it in the foreground as the container's main process.

create a file name default

vi default

Copy the following contents to the default file.

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    
    root /usr/share/nginx/html;
    index index.html index.htm;

    server_name _;
    location / {
        try_files $uri $uri/ =404;
    }
}

The default file you provided is a configuration file for the NGINX web server that is used as the default configuration when creating a Docker image.

docker build -t nginx:1.0 .

-t is for tagging the image.
nginx is the name of the image.
1.0 is the tag name. If you don’t add any tag, it defaults to the tag named latest.
. means, we are referring to the Dockerfile location as the Docker build context.

docker run -d -p 9090:80 --name webserver nginx:1.0

-d flag is for running the container in detached mode
-p flag for the port number, the format is local-port:container-port
--name for the container name, web server in our case

Now just enter http://0.0.0.0:9090/ on your browser to see the webpage

I hope you’ve enjoyed reading this blog as much as I’ve enjoyed writing it Now if you’re feeling inspired to practice and learn, don’t just sit there like a bump on a log! Get out there and start flexing those brain muscles! Learn a new language, try a new skill, or just learn a few new jokes to impress your friends.

And remember, sharing is caring! Don’t keep all that newfound knowledge to yourself, share it with your friends, family, and coworkers. Who knows, you might even inspire them to start learning too! And if not, at least you’ll have someone to tell your new jokes to.

So go forth and learn, my friends! And always remember, knowledge is power, but a good sense of humor is even more powerful.

Conclusion :
Hey there, fellow data enthusiasts! If you’re hooked on my articles and can’t get enough of my witty data humor, then you’re in luck! Here are three ways you can stay connected with me:

A. Follow me on LinkedIn and join my network of awesome data professionals. You’ll never miss a beat when it comes to my latest stories, tips, and tricks.

B. Subscribe to my newsletter, the ultimate insider’s guide to all things data engineering and data visualization. You’ll get exclusive access to new stories, and you can even text me to ask all the burning questions you’ve been dying to know.

C. Become a referred member, and get ready to indulge in an endless buffet of data knowledge. You’ll never have to worry about hitting your “maximum number of stories for the month” limit again, and you’ll get to read everything that I (and thousands of other top data writers) have to say about the newest technology available.

So what are you waiting for? Let’s get connected and start exploring the exciting world of data together! Oh, and don’t forget to bring the coffee — it’s the secret ingredient to unlocking the full potential of your data brainpower. Cheers!

So come on, let’s dive deep into the wonderful world of data together! Check out my website at vizartpandey.com, connect with me on LinkedIn at linkedin.com/in/rajvivan, or shoot me an email at [email protected]. Can’t wait to hear from you!

Learn How to Build and Push a Docker Image to a Docker hub

Data Engineering — Basic Introduction

Demystifying virtualization, containerization, and Docker architecture

Essential Docker Commands You Should Know

Dockerfile

Why do we need to choose a base image while creating a Docker file?

Buy Rajeev Pandey a coffee

More from Rajeev Pandey