Docker for DevOps Engineers

Docker:

Docker is a platform for developing, shipping, and running applications in lightweight, portable containers. Containers bundle an application and all its dependencies, ensuring it runs consistently across different environments. Docker uses images (templates for containers) and provides tools to build, run, and manage containers. It is widely used for development, testing, microservices, and CI/CD pipelines, offering benefits such as portability,  resource efficiency, and scalability.

Docker Commands:

• Start a new container and interact with it through the command line:

  To run a container and interact with it (using the hello-world image):

    docker run -it hello-world
  

  -it: Combines the -i flag (interactive) and -t flag (allocates a pseudo-TTY), so you can interact with the container.

  hello-world: The name of the image to run.

  The hello-world the image will display a message confirming that Docker is working.

• View detailed information about a container or image:

  To inspect a container (use the container ID or name):

    docker inspect <container_name_or_id>
  

  Example:

    docker inspect my_container
  

  To inspect an image:

    docker inspect <image_name>
  

  Example:

    docker inspect hello-world
  

  This command provides detailed information in JSON format, such as configuration, networking, and mounted volumes.

• List the port mappings for a container:

  To view the port mappings for a running container:

    docker port <container_name_or_id>
  

  Example:

    docker port my_container
  

  This will show which local ports are forwarded to container ports.

• View resource usage statistics for one or more containers:

  To view resource usage statistics (CPU, memory, etc.) for one or more containers:

    docker stats <container_name_or_id>
  

  Example:

    docker stats my_container
  

  This command will continuously show resource usage statistics for the container.

  If you want to see stats for all containers, run:

    docker stats
  

• View the processes running inside a container:

  To view the processes running inside a container:

    docker top <container_name_or_id>
  

  Example:

    docker top my_container
  

  This will show the list of processes running inside the container, similar to the ps command.

• Save an image to a tar archive:

  To save a Docker image to a tar archive file:

    docker save -o <output_file.tar> <image_name>
  

  Example:

    docker save -o hello-world.tar hello-world
  

  This command creates a tarball (hello-world.tar) of the hello-world image, which can be transferred or archived.

• Load an image from a tar archive:

  To load a Docker image from a tar archive:

    docker load -i <input_file.tar>
  

  Example:

    docker load -i hello-world.tar
  

  This will load the image stored in hello-world.tar back into Docker.

Dockerfile:

A Dockerfile is a script that includes instructions for building a Docker image. It specifies the environment for your application, detailing which base image to use, which files to copy, which dependencies to install, and the command to execute when the container starts.

Key Dockerfile Instructions:

• FROM: Specifies the base image.

• WORKDIR: Sets the working directory inside the container.

• COPY: Copies files from your machine to the container.

• RUN: Executes commands like installing dependencies.

• EXPOSE: Exposes container ports to the outside.

• CMD: Specifies the default command that will run when the container starts.

Example:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt /app/
RUN pip install -r requirements.txt
COPY . /app
EXPOSE 5000
CMD ["flask", "run"]

To build the image:

docker build -t my-python-app .

To run the container:

docker run -p 5000:5000 my-python-app

This will package your app and make it easy to deploy in any environment.

Docker Image:

A Docker image is a lightweight, standalone package that contains everything needed to run a software application. It includes:

• Code (e.g., your app like app.js)

• Runtime (e.g., Node.js)

• Libraries & Dependencies (installed via npm install)

• System Tools (provided by the base image, like node:16)

Images are used to create containers that run your app consistently across different environments.

Docker Container:

A Docker container is a runnable instance of a Docker image. It’s a lightweight, isolated environment where your application runs, including its code, dependencies, and configurations.

Containers:

• Share the host OS kernel for efficiency.

• Are portable and consistent across environments.

• Can be started, stopped, or deleted without affecting the host system.

Docker Project:

Step 1: Create the Node.js Web Application

1. Create a folder for your project and navigate into it.

mkdir simple-node-app
cd simple-node-app

2. Initialize the Node.js project and install Express.

npm init -y
npm install express

3. Create the application file app.js.

// app.js
const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
    res.send('Hello, World from Dockerized Node.js App!');
});

app.listen(port, () => {
    console.log(`App running at http://localhost:${port}`);
});

4. Create a .dockerignore file to avoid copying unnecessary files into the Docker image.

node_modules
npm-debug.log

Now, you have a basic Node.js web application set up. The app listens on port 3000 and sends a "Hello, World!" message when accessed.

---

Step 2: Create the Dockerfile

Create a Dockerfile in the same directory as your app.js.

# Step 1: Use an official Node.js image as the base
FROM node:16

# Step 2: Set the working directory inside the container
WORKDIR /usr/src/app

# Step 3: Copy package.json and package-lock.json into the container
COPY package*.json ./

# Step 4: Install dependencies
RUN npm install

# Step 5: Copy the rest of the application code into the container
COPY . .

# Step 6: Expose the port the app will run on
EXPOSE 3000

# Step 7: Start the app
CMD ["node", "app.js"]

Step 3: Build the Docker Image

In the terminal, navigate to the folder containing the Dockerfile, then build the Docker image with the following command:

docker build -t simple-node-app .

This command:

• Reads the Dockerfile in the current directory.

• Builds the image and tags it as simple-node-app.

Step 4: Run the Docker Container

Once the image is built, you can run a container based on that image:

docker run -p 3000:3000 simple-node-app

This command:

• Maps port 3000 on your local machine to port 3000 in the container.

• Runs the simple-node-app Docker container.

Step 5: Verify the Application

Now, open your web browser and go to:

http://localhost:3000

You should see the message: "Hello, World from Dockerized Node.js App!".

---

Step 6: Push the Docker Image to Docker Hub

Before pushing the image to Docker Hub, make sure you have an account there. You can create one here.

1. Log in to Docker Hub:

docker login

2. Tag your image for Docker Hub (replace <your-username> with your Docker Hub username):

docker tag simple-node-app <your-username>/simple-node-app:v1

3. Push the image to Docker Hub:

docker push <your-username>/simple-node-app:v1

Now your image is publicly available (or private, depending on your Docker Hub settings) on Docker Hub.

---

Step 7: Pull and Run the Image from the Docker Hub

To verify the image is available on Docker Hub, you can pull it to a different machine or container environment:

docker pull <your-username>/simple-node-app:v1

Then, run it:

docker run -p 3000:3000 <your-username>/simple-node-app:v1

Visit http://localhost:3000 to confirm it's working.