docker / cli

Production Scaling with Docker CLI

The following details the process for scaling the Docker CLI project in production. The scaling approach covers services orchestration with docker-compose and considerations during the build process using Dockerfile and Makefile.

Scaling Services with Docker Compose

The docker-compose.yml file defines multiple services essential for scaling in a production environment. Each service is individually defined with their respective configurations.

Example docker-compose.yml

version: "2"
services:
  server:
    build:
      context: .
      dockerfile: server.Dockerfile
    networks:
      - mdb
      - sig
    ports:
      - "8080"
      - "4443:4443"
    entrypoint: /usr/bin/env sh
    command: -c "./migrations/migrate.sh && notary-server -config=fixtures/server-config.json"
    depends_on:
      - mysql
      - signer
  signer:
    build:
      context: .
      dockerfile: signer.Dockerfile
    networks:
      mdb:
      sig:
        aliases:
          - notarysigner
    entrypoint: /usr/bin/env sh
    command: -c "./migrations/migrate.sh && notary-signer -config=fixtures/signer-config.json"
    depends_on:
      - mysql
  mysql:
    networks:
      - mdb
    volumes:
      - ./notarysql/mysql-initdb.d:/docker-entrypoint-initdb.d
      - notary_data:/var/lib/mysql
    image: mariadb:10.4
    environment:
      - TERM=dumb
      - MYSQL_ALLOW_EMPTY_PASSWORD="true"
    command: mysqld --innodb_file_per_table
volumes:
  notary_data:
    external: false
networks:
  mdb:
    external: false
  sig:
    external: false
Notes on the Configuration:
  • Service Definition: Each service (server, signer, mysql) is encapsulated with its build context and dependencies.
  • Networks: Each service is connected through logical networks (mdb and sig), enhancing communication between services while isolating them from others.
  • Ports: Necessary ports are exposed to facilitate access.
  • Entrypoints and Commands: Manage initialization processes and application startup ensuring all services start in the correct sequence.

Building with Dockerfile

The Dockerfile manages how each service is built, ensuring optimized layers and necessary dependencies are included for production scalability.

Example Dockerfile

# syntax=docker/dockerfile:1

ARG BASE_VARIANT=alpine
ARG GO_VERSION=1.23.3
ARG GOVERSIONINFO_VERSION=v1.4.1
ARG GOTESTSUM_VERSION=v1.10.0
ARG BUILDX_VERSION=0.18.0
ARG COMPOSE_VERSION=v2.30.3

FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS build

WORKDIR /go/src/github.com/docker/cli

COPY . .

RUN go mod tidy && go build -o ./build/cli ./cmd/cli

FROM scratch
COPY --from=build /go/src/github.com/docker/cli/build/cli /usr/local/bin/cli
Important Aspects of the Build Process:
  • Multi-Stage Builds: Reduces final image size while ensuring build dependencies are isolated.
  • Go Modules: The build leverages Go modules (go mod) for dependency management.
  • Static Binaries: Outputs statically linked binaries which are more portable and easier to deploy in Docker containers.

Makefile for Build Automation

The Makefile provides shortcuts for various build automation tasks such as testing and cleaning up.

Example Makefile

all: binary

binary:
    go build -o ./build/cli ./cmd/cli

test:
    go test ./...

clean:
    rm -rf ./build/*
Custom Functions:
  • binary: Automates the build process for creating the CLI application.
  • test: Runs unit tests to ensure code quality and stability.
  • clean: Facilitates cleanup of build artifacts.

Steps to Scale in Production

  1. Define Services in docker-compose: Configure service dependencies, networks, and ports in the docker-compose.yml file.

  2. Create Optimized Dockerfile: Implement a Dockerfile focused on multi-stage builds to minimize image size and ensure all required binaries are compiled correctly.

  3. Automate Builds with Makefile: Utilize a Makefile to simplify the build, test, and cleanup process, allowing for consistent executions with reduced overhead.

  4. Deploy and Scale: Use docker-compose up --scale server=<number> and --scale signer=<number> to scale the services in production as required.

  5. Monitor and Optimize: Continuous monitoring of service performance and resource consumption is critical to identify bottlenecks and further optimize scaling.

This document utilized the original project’s structures and specifications to detail the scaling approach in a production environment for expert developers working with Docker CLI.

Source: The details are derived from the provided code structures in docker-compose.yml, Dockerfile, and Makefile.