Docker and Docker compose for beginners
Tags: beginners, devops, docker
Published: 2023-04-29 21:07:20


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x5glbnv2jy0zcm85meg2.png)

**What is Docker and why the need for docker?
**
Docker is an open-source containerization technology that allows developers to package applications and dependencies into a single deployable unit. Docker Compose is a tool that enables developers to define and run multi-container Docker applications. In this article, we will explore the syntax of a docker-compose.yml file, its similarities with a JSON file, and how to create services in a docker-compose.yml file.

Note: "Containers" in the context of Docker Compose refers to the individual services defined in the docker-compose.yml file. Each service is typically run in its own Docker container, and Docker Compose is used to manage the interactions between these containers.

For example, you might have a web service that runs a web server in one container, a database service that runs a database server in another container, and a worker service that performs background tasks in yet another container. Each of these services would be defined in the docker-compose.yml file as a separate service, and Docker Compose would be used to manage their interactions, such as linking the web service to the database service and configuring the worker service to use environment variables provided by the web service.

To put it simply, docker eliminates the confusion of _"...but it works on my computer..."_, and ensuring that your code, services and everything else associated with your program works as intended no matter the computer or operating system it is running on.

**The Syntax of a Docker-Compose.yml File
**
A Docker Compose file is a YAML file that defines how Docker containers should behave in production. A YAML file is a human-readable data serialization language that is commonly used for configuration files. The syntax of a docker-compose.yml file is straightforward and easy to understand. The file begins with a version declaration, followed by a list of services that define the containers that make up an application. The following is an example of a simple docker-compose.yml file:

```
version: "3.9"

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"

```
In this example, the version declaration specifies the version of the Docker Compose file format to use. The services section defines a single service named web. This service is composed of an nginx container that listens on port 80 and is exposed on the host machine on port 8080.

**Similarities with JSON
**
YAML is often compared to JSON because both are used to represent data in a structured way. JSON is a lightweight data interchange format that is commonly used for web applications. JSON syntax is simpler than YAML but is less expressive. YAML, on the other hand, is more expressive but can be more complex to read and write.

The syntax of a docker-compose.yml file is similar to that of a JSON file. Both formats use key-value pairs to define data structures. However, YAML is more human-readable and allows for more complex data structures. The following is an example of the same docker-compose.yml file in JSON format:

```
{
  "version": "3.9",
  "services": {
    "web": {
      "image": "nginx:latest",
      "ports": [
        "8080:80"
      ]
    }
  }
}

```
As you can see, the JSON format uses curly braces and commas to separate key-value pairs, while YAML uses indentation and colons. Also, arrays in the JSON format uses square braces whereas in YAML indentations are used with each element of the _array_ separated by a hyphen. While the syntax of the two formats is different, the data structures they represent are the same.

**Creating Services in a Docker-Compose.yml File
**
A service in a docker-compose.yml file defines a container that is part of an application. The following sections describe how to create services in a docker-compose.yml file.

**Defining the Image
**
The image key is used to specify the Docker image to use for the service. The image can be specified by name and tag or by a URL to a Docker registry. For example, the following defines a service that uses the official Node.js image:

```
services:
  app:
    image: node:14

```
**Defining Ports
**
The ports key is used to specify the ports to expose from the container. The ports are defined as a list of mappings between the host port and the container port. For example, the following maps port 8080 on the host machine to port 80 on the container:

```
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"

```
**Defining Volumes
**
The volumes key is used to specify the volumes to mount in the container. Volumes are used to persist data between container restarts and to share data between containers. For example, the following mounts a host directory to a directory inside the container:

```
services:
  db:
    image: postgres:latest
    volumes:
      - data:/data

volumes:
  data:

```
In this example, we define a named volume called data, and we mount it to the /data directory inside the db service container.

**Defining Environment Variables
**
Environment variables are used to pass configuration information to a container at runtime. To define environment variables in a docker-compose.yml file, you can use the environment key. The following is an example:

```
services:
  web:
    image: nginx:latest
    environment:
      - APP_ENV=production
      - DB_HOST=db

```
In this example, we define two environment variables for the web service. The APP_ENV variable is set to production, and the DB_HOST variable is set to the hostname of the db service container.

**Defining Dependencies between Services
**
Docker Compose allows you to define dependencies between services using the depends_on key. The following is an example:

```
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    depends_on:
      - db

  db:
    image: postgres:latest

```
In this example, we define two services: web and db. The web service depends on the db service, which means that Docker Compose will start the db service before the web service.

**Conclusion
**
In this article, we have explored the syntax of a docker-compose.yml file, its similarities with a JSON file, and how to create services in a docker-compose.yml file. Docker Compose is a powerful tool for defining and running multi-container Docker applications. By using the docker-compose.yml file, you can easily define and manage the containers that make up your application, including their dependencies, ports, volumes, and environment variables. With Docker Compose, you can deploy your application quickly and efficiently, without worrying about the complexity of managing individual containers.