Docker pratique pour les débutants Golang Dev

Table des matières

1. Aperçu
2. Prérequis
3. Fichier Docker
4. Docker Composer
   • Nginx
   • Mysql
   • Migrer
   • API
   • Personnalisé
5. Références

Aperçu

Cet article n'expliquera pas comment Docker fonctionne sur le capot, mais cet article expliquera à quoi sert chaque code écrit sur Dockerfile et le fichier docker-compose.yml afin que nous puissions écrire notre configuration Docker pour un autre projet.

Condition préalable

Nous avons besoin d'un projet avec Dockerfile et docker-compose par exemple, ici nous utiliserions le projet Golang nommé Ecom comme exemple. Pour utiliser Dockerfile, vous devez configurer la base de données locale comme mentionné dans README.

Fichier Docker

Dockerfile utilisé pour créer une image de conteneur.(6)

# Build application from source
FROM golang:1.23.0 AS build-stage
    WORKDIR /app

    COPY go.mod go.sum ./
    RUN go mod download

    COPY . .

    RUN CGO_ENABLED=0 GOOS=linux go build -o /api ./cmd/main.go

• DEpuis golang : 1.23.0 COMME l'étape de construction, il s'agit d'une image pour notre application, c'est similaire à la façon dont nous téléchargeons le moteur Go sur notre machine, Docker a besoin d'une image spécifique pour exécuter notre code.(1)(2)

• WORKDIR /app c'est le répertoire de travail dans lequel nous voulons que notre code soit exécuté dans /app.

• COPIER go.mod go.sum ./ ce code copiera les fichiers go.mod et go.sum de la machine locale vers le répertoire ./ sur Docker.

• RUN go mod download cela exécutera la commande go mod download sur Docker

• COPIER . . ce code copiera tous les projets de fichiers et de dossiers de la machine locale vers Docker.

• RUN CGO_ENABLED=0 GOOS=linux go build -o /api ./cmd/main.go ce code exécutera la commande pour créer l'application Golang sur le système d'exploitation Linux dans le dossier /api sur Docker.
  

# Deploy application binary into a lean image
FROM scratch AS build-realease-stage
    WORKDIR /

    COPY --from=build-stage /api /api

    EXPOSE 8080

    ENTRYPOINT [ "/api" ]

• FROM scratch AS build-realease-stage scratch utilisé pour créer des images minimales contenant uniquement ce dont une application a besoin.

• WORKDIR / nous utiliserons root / comme répertoire de travail.

• COPY --from=build-stage /api /api cela copiera le répertoire /api de l'étape de construction de l'image vers /api sur l'image de l'étape de construction-realease.

• EXPOSE 8080 cela exposera le port 8080 afin que nous puissions accéder à l'API avec le port 8080 en dehors de Docker.

• ENTRYPOINT [ "/api" ] cela définira l'exécutable par défaut sur /api

Essayons notre Dockerfile.

sudo docker build .

docker build pour construire notre projet dans une image. Vous pouvez ajouter des balises -t project-ecom pour identifier plus facilement les images que vous créez.(3)

Vous pouvez consulter la liste des images avec la commande sudo docker image ls

# Build application from source
FROM golang:1.23.0 AS build-stage
    WORKDIR /app

    COPY go.mod go.sum ./
    RUN go mod download

    COPY . .

    RUN CGO_ENABLED=0 GOOS=linux go build -o /api ./cmd/main.go

Ensuite, exécutez notre image Docker
--rm pour supprimer le conteneur à l'arrêt
--hôte réseau pour connecter l'application Docker à la machine hôte locale (4), (5)
--env-file .env pour accéder à la valeur de l'environnement via le fichier .env
98bc0128576e ID d'image Docker

Félicitation

Vous pouvez désormais tester l'API Consume avec Postman ou d'autres applications.

Docker Composer

Docker Compose était utilisé pour créer plusieurs services de conteneurs et les exécuter dans Docker. Dans ce projet docker-compose.yml il y a 4 services que nous allons expliquer.

Proxy Nginx

# Build application from source
FROM golang:1.23.0 AS build-stage
    WORKDIR /app

    COPY go.mod go.sum ./
    RUN go mod download

    COPY . .

    RUN CGO_ENABLED=0 GOOS=linux go build -o /api ./cmd/main.go

• nginx : c'est le nom du service
• image : nginxproxy/nginx-proxy:1.6 c'est l'image que nous utiliserons, similaire à FROM chez Dockerfile.
• réseaux : c'est le réseau à l'intérieur de Docker que le service utilisera.
• ports : il s'agit de définir le port pour que le service utilise : , 80 est le port par défaut pour HTTP
• volumes : il s'agit d'un volume persistant pour stocker les données de ce service, : :ro (lecture seule).
• environnement : il s'agit d'utiliser une variable d'environnement.(8)

MySQL

# Deploy application binary into a lean image
FROM scratch AS build-realease-stage
    WORKDIR /

    COPY --from=build-stage /api /api

    EXPOSE 8080

    ENTRYPOINT [ "/api" ]

• db : c'est le nom du service
• image : mysql : 8.0 ce service utilisant Image mysql version 8.0
• réseaux : ce service utilisant un réseau personnalisé nommé nouveau puis le nouveau réseau utilisant la base de données de noms d'alias
• healthcheck : il s'agit de vérifier le fonctionnement du service en exécutant un test, test : mysqladmin ping -h database -u ${DB_USER} --password=${DB_PASSWORD} ce test ping une base de données mysql.
• volumes : il s'agit de stocker des données persistantes dans le volume.
• ports : c'est le port que le service utilisera, dans ce service, nous utilisons 3308 comme port de machine locale car le port 3306 est déjà utilisé pour MySQL sur notre machine locale.
• environnement : il s'agit d'utiliser une variable d'environnement, dans ce service mysql, nous avons besoin du mot de passe root et du nom de la base de données.(7)

Émigrer

sudo docker build .

• migrate-up : c'est le nom du service
• image : migrer/migrer ce service, utilisez migrate Image
• réseaux : ce service utilise le réseau nouveau, identique au service db
• volumes : les données de migration du ./cmd/migrate/migrations local ont été copiées dans le répertoire de service /migrations
• commande : il s'agit d'exécuter une commande sur ce service, ["-path", "/migrations", "-database", "${CONNECT_DB}", "-verbose", "up"] cette commande similaire à migrate -path /migrations -database mysql://root:some-secret-password@tcp(database:3306)/ecom -verbose up. (9)
• liens : ceci pour lier le service à un autre service, ce service de migration lié au service db
• depend_on : ceci pour que ce service soit exécuté après certaines conditions, db : condition : service_healthy, cela signifie que le service de migration sera exécuté lorsque le test du service db aura obtenu le résultat service_healthy.

API

# Build application from source
FROM golang:1.23.0 AS build-stage
    WORKDIR /app

    COPY go.mod go.sum ./
    RUN go mod download

    COPY . .

    RUN CGO_ENABLED=0 GOOS=linux go build -o /api ./cmd/main.go

• api : c'est le nom du service
• réseaux : il s'agit du réseau pour ce service, ce service utilise le nouveau réseau pour pouvoir se connecter à la base de données du service, ainsi que se connecter au réseau par défaut utilisé par le service nginx.
• build : il s'agit de construire le service, ce service en utilisant Dockerfile.
• redémarrage : ce service redémarrera chaque fois que le service échoue
• volumes : il s'agit de données persistantes stockées sur le volume /go/src/api.
• ports : port pour ce service.
• environnement : l'environnement valorise ce service nécessaire.
• liens : ce service est lié au service db car il doit consommer la base de données mysql.
• depend_on : ce service sera exécuté sous plusieurs conditions, lors de la migration : déjà service_completed_successfully, lorsque le résultat du test de base de données est service_healthy et lorsque nginx service_started

Coutume

# Deploy application binary into a lean image
FROM scratch AS build-realease-stage
    WORKDIR /

    COPY --from=build-stage /api /api

    EXPOSE 8080

    ENTRYPOINT [ "/api" ]

• volumes : cela a créé un volume personnalisé nommé db_data :
• réseaux : cela a créé des réseaux personnalisés nommés nouveaux

Essayons notre Docker Compose

sudo docker build .

Cette commande créera des images pour chaque service et exécutera chaque conteneur.

sudo docker run --rm --network host --env-file .env 98bc0128576e

Vous pouvez vérifier le conteneur créé par notre docker-compose.yml.

  nginx:
    image: nginxproxy/nginx-proxy:1.6
    networks:
      - default
    ports:
      - "80:80"
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    environment:
      HTTPS_METHOD: nohttps

Vous pouvez vérifier le volume créé par notre docker-compose.yml.

  db:
    image: mysql:8.0
    networks:
      new:
        aliases:
          - database
    healthcheck:
      test: mysqladmin ping -h database -u ${DB_USER} --password=${DB_PASSWORD}
    volumes:
      - db_data:/var/lib/mysql
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3308:3306"
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_DATABASE: ${DB_NAME}

Vous pouvez vérifier les images créées par notre docker-compose.yml.

Félicitation

Vous pouvez tester l'API Consume de notre projet sur la base de la documentation sur README avec Postman ou d'autres applications.

si vous l'avez fait vous pouvez arrêter le conteneur avec,

  migrate-up:
    image: migrate/migrate
    networks:
      - new
    volumes:
      - ./cmd/migrate/migrations:/migrations
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    command: ["-path", "/migrations", "-database", "${CONNECT_DB}", "-verbose", "up"]
    links:
      - db
    depends_on:
      db:
        condition: service_healthy

Ou si vous souhaitez supprimer tous les services de conteneurs dans Docker Compose, vous pouvez les exécuter,

# Build application from source
FROM golang:1.23.0 AS build-stage
    WORKDIR /app

    COPY go.mod go.sum ./
    RUN go mod download

    COPY . .

    RUN CGO_ENABLED=0 GOOS=linux go build -o /api ./cmd/main.go

Références

(1)Référence du fichier Docker
(2)Image de base Docker
(3) Construction de Docker
(4) Tutoriels du réseau Docker
(5) Pilotes réseau Docker
(6)Écrire un fichier Docker
(7) Docker Hub Mysql
(8)Documents Nginx-Proxy
(9) Golang Migrer

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!