Docker Compose: uw werk vereenvoudigen met Makefiles

Elke paar jaar ondergaat de softwareontwikkelingsindustrie een paradigmaverschuiving. Eén van deze fenomenen kan worden herkend als de groeiende belangstelling voor het concept van microservices. Hoewel microservices niet de nieuwste technologie zijn, is de populariteit ervan pas onlangs letterlijk omhooggeschoten.

Grote monolithische diensten worden nu vervangen door onafhankelijke, autonome microdiensten. Een microservice kan worden gezien als een applicatie die een enkel en zeer specifiek doel dient. Het kan bijvoorbeeld een relationeel DBMS, een Express-applicatie of een Solr-service zijn.

Tegenwoordig is het moeilijk voor te stellen dat je een nieuw softwaresysteem zou ontwikkelen zonder gebruik te maken van microservices. En deze situatie leidt ons op zijn beurt naar het Docker-platform.

havenarbeider

Platform havenarbeider, bij de ontwikkeling en implementatie van microservices, is bijna een industriestandaard geworden. Op de projectwebsite kun je ontdekken dat Docker het enige onafhankelijke containerisatieplatform is waarmee organisaties moeiteloos elke applicatie kunnen maken, maar ook kunnen distribueren en uitvoeren in elke omgeving - van hybride clouds tot edge-systemen.

Docker Compose

Технология Docker Compose ontworpen voor het configureren van toepassingen met meerdere containers. Een Docker Compose-project kan zoveel Docker-containers bevatten als de maker van het project nodig heeft.

Bij het werken met Docker Compose wordt een YAML-bestand gebruikt om applicatieservices te configureren en hun interactie met elkaar te organiseren. Docker Compose is daarom een ​​tool voor het beschrijven en uitvoeren van Docker-applicaties met meerdere containers.

Twee containers die op een hostsysteem draaien

GNU-merk

Programma make, is in wezen een hulpmiddel voor het automatiseren van het bouwen van programma's en bibliotheken op basis van broncode. Over het algemeen kunnen we dat zeggen make is van toepassing op elk proces waarbij willekeurige opdrachten worden uitgevoerd om bepaald invoermateriaal om te zetten in een uitvoervorm, of een bepaald doel. In ons geval de commando's docker-compose zal worden omgezet in abstracte doelen (Telefoondoelen).

Om het programma te vertellen make over wat we ervan willen, we hebben een bestand nodig Makefile.

In onze Makefile zal reguliere opdrachten bevatten docker и docker-compose, die zijn ontworpen om veel problemen op te lossen. We hebben het namelijk over het samenstellen van een container, over het starten, stoppen en opnieuw opstarten ervan, over het organiseren van gebruikersaanmelding bij de container, over het werken met containerlogboeken en over het oplossen van andere soortgelijke problemen.

Typische gebruiksscenario's voor Docker Compose

Laten we ons een gewone webapplicatie voorstellen die de volgende componenten heeft:

• TimescaleDB-database (Postgres).
• Express.js-toepassing.
• Ping (slechts een container, doet niets bijzonders).

Deze applicatie heeft 3 Docker-containers en een bestand nodig docker-compose, dat instructies bevat voor het beheer van deze containers. Elke container heeft verschillende contactpunten. Bijvoorbeeld met een container timescale het zal mogelijk zijn om ongeveer op dezelfde manier te werken als met databases. Hiermee kunt u namelijk de volgende acties uitvoeren:

• Inloggen op de Postgres-shell.
• Importeren en exporteren van tabellen.
• schepping pg_dump tabellen of databases.

Express.js-applicatiecontainer, expressjs, kan de volgende mogelijkheden hebben:

• Het verstrekken van nieuwe gegevens uit het systeemlogboek.
• Log in op de shell om bepaalde opdrachten uit te voeren.

Interactie met containers

Zodra we de communicatie tussen containers hebben opgezet met behulp van Docker Compose, is het tijd om met die containers te communiceren. Binnen het Docker Compose-systeem is er een opdracht docker-compose, ondersteunende optie -f, waarmee u een bestand naar het systeem kunt overbrengen docker-compose.yml.

Met behulp van de mogelijkheden van deze optie kunt u de interactie met het systeem beperken tot alleen de containers die in het bestand worden vermeld docker-compose.yml.

Laten we eens kijken hoe interacties met containers eruit zien bij het gebruik van opdrachten docker-compose. Als we ons voorstellen dat we moeten inloggen op de shell psql, dan kunnen de bijbehorende opdrachten er als volgt uitzien:

docker-compose -f docker-compose.yml exec timescale psql -Upostgres

Hetzelfde commando dat niet wordt gebruikt om uit te voeren docker-composeEn docker, zou er zo uit kunnen zien:

docker exec -it  edp_timescale_1 psql -Upostgres

Houd er rekening mee dat het in dergelijke gevallen altijd de voorkeur verdient om de opdracht te gebruiken dockeren de opdracht docker-compose, omdat dit de noodzaak elimineert om containernamen te onthouden.

Beide bovenstaande commando's zijn niet zo moeilijk. Maar als we een “wrapper” in het formulier gebruiken Makefile, wat ons een interface zou geven in de vorm van eenvoudige commando's en die zelf soortgelijke lange commando's zou aanroepen, dan zouden dezelfde resultaten als volgt kunnen worden bereikt:

make db-shell

Het is vrij duidelijk dat het gebruik Makefile maakt het werken met containers veel gemakkelijker!

Werkend voorbeeld

Op basis van het bovenstaande projectdiagram maken we het volgende bestand docker-compose.yml:

version: '3.3'
services:
    api:
        build: .
        image: mywebimage:0.0.1
        ports:
            - 8080:8080
        volumes:
            - /app/node_modules/
        depends_on:
            - timescale
        command: npm run dev
        networks:
            - webappnetwork
    timescale:
        image: timescale/timescaledb-postgis:latest-pg11
        environment:
          - POSTGRES_USER=postgres
          - POSTGRES_PASSWORD=postgres
        command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"]
        volumes:
          - ./create_schema.sql:/docker-entrypoint-initdb.d/create_schema.sql
        networks:
           - webappnetwork
    ping:
       image: willfarrell/ping
       environment:
           HOSTNAME: "localhost"
           TIMEOUT: 300
networks:
   webappnetwork:
       driver: bridge

Om de Docker Compose-configuratie te beheren en te communiceren met de containers die daarin worden beschreven, zullen we het volgende bestand maken Makefile:

THIS_FILE := $(lastword $(MAKEFILE_LIST))
.PHONY: help build up start down destroy stop restart logs logs-api ps login-timescale login-api db-shell
help:
        make -pRrq  -f $(THIS_FILE) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$'
build:
        docker-compose -f docker-compose.yml build $(c)
up:
        docker-compose -f docker-compose.yml up -d $(c)
start:
        docker-compose -f docker-compose.yml start $(c)
down:
        docker-compose -f docker-compose.yml down $(c)
destroy:
        docker-compose -f docker-compose.yml down -v $(c)
stop:
        docker-compose -f docker-compose.yml stop $(c)
restart:
        docker-compose -f docker-compose.yml stop $(c)
        docker-compose -f docker-compose.yml up -d $(c)
logs:
        docker-compose -f docker-compose.yml logs --tail=100 -f $(c)
logs-api:
        docker-compose -f docker-compose.yml logs --tail=100 -f api
ps:
        docker-compose -f docker-compose.yml ps
login-timescale:
        docker-compose -f docker-compose.yml exec timescale /bin/bash
login-api:
        docker-compose -f docker-compose.yml exec api /bin/bash
db-shell:
        docker-compose -f docker-compose.yml exec timescale psql -Upostgres

De meeste hier beschreven opdrachten zijn van toepassing op alle containers, maar gebruiken de optie c= Hiermee kunt u de reikwijdte van een opdracht beperken tot één container.

Na Makefile klaar, je kunt het als volgt gebruiken:

• make help — het uitgeven van een lijst met alle beschikbare commando's make.

Hulp bij beschikbare opdrachten

• make build - een afbeelding samenstellen uit Dockerfile. In ons voorbeeld hebben we bestaande afbeeldingen gebruikt timescale и ping. Maar het beeld api wij willen lokaal verzamelen. Dit is precies wat er zal gebeuren na het uitvoeren van deze opdracht.

Een Docker-container bouwen

• make start — het lanceren van alle containers. Om slechts één container te starten, kunt u een opdracht als make start c=timescale.

De tijdschaalcontainer uitvoeren

Een ping-container uitvoeren

• make login-timescale — log in op de bash-sessie van de container timescale.

Bash uitvoeren in een tijdschaalcontainer

• make db-shell - toegang tot psql in een container timescale om SQL-query's op de database uit te voeren.

Psql uitvoeren in een tijdschaalbare container

• make stop — containers tegenhouden.

Een tijdschaalcontainer stoppen

• make down — het stoppen en verwijderen van containers. Om een ​​specifieke container te verwijderen, kunt u deze opdracht gebruiken en de gewenste container opgeven. Bijvoorbeeld - make down c=timescale of make down c=api.

Alle containers stoppen en verwijderen

Resultaten van

Hoewel Docker Compose ons een uitgebreide reeks opdrachten biedt voor het beheren van containers, kunnen deze opdrachten soms lang en moeilijk te onthouden worden.

Wijze van gebruik Makefile heeft ons geholpen om snelle en gemakkelijke interactie met containers uit een bestand tot stand te brengen docker-compose.yml. We hebben het namelijk over het volgende:

• De ontwikkelaar heeft alleen interactie met de projectcontainers die worden beschreven in docker-compose.ymlwordt het werk niet gehinderd door andere lopende containers.
• Mocht u een bepaald commando vergeten, dan kunt u het commando uitvoeren make help en krijg hulp bij beschikbare opdrachten.
• U hoeft geen lange lijsten met argumenten te onthouden om acties uit te voeren, zoals het ophalen van de nieuwste logboekgegevens of het inloggen op een systeem. Een commando als bijvoorbeeld docker-compose -f docker-compose.yml exec timescale psql -Upostgres verandert in make db-shell.
• file Makefile Je kunt je er flexibel op aanpassen naarmate het project groeit. U kunt bijvoorbeeld eenvoudig een opdracht toevoegen om een ​​databaseback-up te maken of een andere actie uit te voeren.
• Als een groot team van ontwikkelaars hetzelfde gebruikt MakefileDit stroomlijnt de samenwerking en vermindert fouten.

PS In onze marktplaats er is een afbeelding havenarbeider, die met één klik kan worden geïnstalleerd. De werking van containers kunt u controleren op VPS. Alle nieuwe klanten krijgen 3 dagen gratis testen.

Beste lezers! Hoe automatiseer je Docker Compose?

Bron: www.habr.com