Docker is a platform for developing, shipping, and running applications in containers. Containers are lightweight and contain everything needed to run an application, making them portable and consistent across environments.

Here’s a brief tutorial on Docker, including creating containers, networking between containers, and setting up a simple multi-container application involving a database, cache, and services written in Node.js and Go.

1. Install Docker

Install Docker from Docker’s official website

2. Basic Docker Commands

Pull an image:

docker pull <image-name>

Example:

docker pull node:14

Run a container:

docker run -d – name <container-name> <image-name>

Example:

docker run -d – name my-node-container node:14

List running containers:

docker ps

Stop a container:

docker stop <container-name>

Remove a container:

docker rm <container-name>

3. Creating a Node.js Application Container

Create a simple Node.js application:

mkdir node-app
cd node-app
npm init -y
npm install express

2. Create app.js:

const express = require(‘express’);
const app = express();
const PORT = 3000;

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

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

3. Create `Dockerfile:

Dockerfile

`
FROM node:14

WORKDIR /usr/src/app

COPY package.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["node", "app.js"]
`

4. Build the Docker image:

docker build -t node-app .

5. Run the container:

docker run -d – name node-app-container -p 3000:3000 node-app

Creating a Go Application Container

Create a simple Go application:


mkdir go-app
cd go-app


2. Create main.go:

`
package main

import (
"fmt"
"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello from Go!")
}

func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
`

3. Create Dockerfile:

Dockerfile

`
FROM golang:1.16

WORKDIR /app

COPY . .

RUN go build -o main .

EXPOSE 8080

CMD ["./main"]
`

4. Build the Docker image:

docker build -t go-app .

5. Run the container:

docker run -d – name go-app-container -p 8080:8080 go-app

5. Setting Up a Database Container

Run a PostgreSQL container:


docker run -d – name postgres-container -e POSTGRES_PASSWORD=mysecretpassword -e POSTGRES_DB=mydatabase -p 5432:5432 postgres


6. Setting Up a Redis Cache Container

Run a Redis container:
docker run -d – name redis-container -p 6379:6379 redis

7. Networking Between Containers

Docker provides several ways to network containers. The simplest way is to use Docker’s default bridge network.

Create a custom network:

docker network create my-network

2. Run containers in the same network:


docker run -d – name postgres-container – network my-network -e POSTGRES_PASSWORD=mysecretpassword -e POSTGRES_DB=mydatabase postgres
docker run -d – name redis-container – network my-network redis
docker run -d – name node-app-container – network my-network -p 3000:3000 node-app
docker run -d – name go-app-container – network my-network -p 8080:8080 go-app


8. Connecting Services to Database and Cache

Example Node.js (app.js) connecting to PostgreSQL and Redis:

Install dependencies:

npm install pg redis

Modify app.js:

`
const express = require('express');
const { Pool } = require('pg');
const redis = require('redis');
const app = express();
const PORT = 3000;
const pool = new Pool({
user: 'postgres',
host: 'postgres-container',
database: 'mydatabase',
password: 'mysecretpassword',
port: 5432,
});

const client = redis.createClient({
host: 'redis-container',
port: 6379,
});

app.get('/', async (req, res) => {
const result = await pool.query('SELECT NOW()');

client.set('key', 'value');

client.get('key', (err, value) => {
res.send(PostgreSQL time: ${result.rows[0].now}, Redis value: ${value});
});

});

app.listen(PORT, () => {
console.log(Server is running on port ${PORT});
});
`

Example Go (main.go) connecting to PostgreSQL and Redis:

Install dependencies:

go get github.com/lib/pq
go get github.com/go-redis/redis/v8

2. Modify main.go:

`
package main

import (
"context"
"database/sql"
"fmt"
"net/http"
"github.com/go-redis/redis/v8"
_ "github.com/lib/pq"
)

var ctx = context.Background()

func handler(w http.ResponseWriter, r *http.Request) {
connStr := "user=postgres password=mysecretpassword dbname=mydatabase host=postgres-container sslmode=disable"
db, err := sql.Open("postgres", connStr)

if err != nil {
panic(err)
}

defer db.Close()

var now string
err = db.QueryRow("SELECT NOW()").Scan(&now)

if err != nil {
panic(err)
}

rdb := redis.NewClient(&redis.Options{
Addr: "redis-container:6379",
})

err = rdb.Set(ctx, "key", "value", 0).Err()

if err != nil {
panic(err)
}

val, err := rdb.Get(ctx, "key").Result()

if err != nil {
panic(err)
}

fmt.Fprintf(w, "PostgreSQL time: %s, Redis value: %s", now, val)
}

func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
`

9. Docker Compose

To simplify the process, you can use Docker Compose to define and run multi-container Docker applications.

Create docker-compose.yml:

`
version: '3'

services:
postgres:
image: postgres
environment:
POSTGRES_PASSWORD: mysecretpassword
POSTGRES_DB: mydatabase
networks:
- my-network

redis:
image: redis
networks:
- my-network

node-app:
build: ./node-app
ports:
- "3000:3000"
networks:
- my-network

go-app:
build: ./go-app
ports:
- "8080:8080"
networks:
- my-network

networks:
my-network:
driver: bridge
`

Run the application:

docker-compose up – build

By following this tutorial, you can set up a multi-container application with Docker, including networking between containers and connecting services to a database and cache.