7.5.1. Creating a Docker Container

A Docker container encapsulates everything needed to run an application, including the operating system, libraries, and dependencies. This eliminates the "works on my machine" problem.

A Docker container is a lightweight, standalone executable package that includes everything needed for an application to run. This means the code, runtime, system tools, libraries, and settings are all included in this package when you create it. By using containers, developers avoid discrepancies between different environments (like development and production), ensuring that if it works on your machine, it will work anywhere, as all dependencies and settings are consistent.

Think of a Docker container like a shipping container for a product. Just as a shipping container holds everything needed to transport goods securely and reliably regardless of the shipping method or location, a Docker container holds everything needed to run your application, ensuring it behaves the same way in any environment.

Example Dockerfile:

FROM node:14
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

A Dockerfile includes a series of commands that Docker uses to create a container image. The commands in this Dockerfile begin with FROM that specifies which base image to use—in this case, Node.js version 14. The WORKDIR sets the working directory inside the container. The COPY commands transfer files, including the package dependencies, and RUN npm install installs those dependencies. The EXPOSE command indicates the port on which the app will run, and CMD specifies the command that Docker will use when starting the container.

Imagine the Dockerfile as a recipe for baking a cake. The FROM is like choosing the type of cake you're going to make (e.g., chocolate cake), the WORKDIR sets your kitchen workspace, COPY adds your ingredients (like flour and sugar), RUN is when you mix and bake those ingredients, EXPOSE is telling guests what delicious flavor will come from the oven, and CMD is the moment you serve the cake to your guests.

To build and run a Docker container:

docker build -t my-app .
docker run -p 3000:3000 my-app

To create a Docker container, you use the docker build command with the -t flag to tag your image with a name (in this example, 'my-app'). The dot (.) signifies the current directory where your Dockerfile is found. After building the image, you must run it using docker run, which also specifies port mapping (-p 3000:3000). This means that requests to port 3000 on your host machine are forwarded to port 3000 on the container, allowing you to access the app running inside the container.

Consider this step as taking an archery set from the storage (the image you've built) and using it at the local archery range (your run command). docker build is like unpacking your archery set, setting it up with your preferred adjustments, and then docker run is analogous to actually stepping up to the range and taking aim.

When developing full-stack applications, you often need multiple services (e.g., a Node.js app and a database). Docker Compose allows you to define and run multi-container applications. Example docker-compose.yml:

version: '3'
services:
  app:
    build: .
    ports:
      - "3000:3000"
  db:
    image: mongo
    ports:
      - "27017:27017"

Docker Compose is a tool for defining and running multi-container Docker applications with a simple YAML configuration file (docker-compose.yml). Here, two services are defined: app, which is your application that will be built from the current directory, and db, which is a MongoDB service. Each service specifies which ports to expose. This allows developers to easily manage multiple interconnected containers, which is especially useful for full-stack applications that have separate services for the front end, back end, and any databases.

You can think of Docker Compose as planning a multi-course meal; each course is prepared in a different kitchen (service). The docker-compose.yml file is like your meal plan that outlines which kitchen will prepare which dish and how the courses (services) will come together to create a complete meal experience for your guests. Typically, you want to ensure that each course is served at the right time and is ready for the next course's arrival.

--