Komplett guide til distribusjon av applikasjoner med Docker Compose

Å jobbe med containere har blitt en hverdag For nesten alle utviklingsteam, og når en applikasjon går utover en enkel tjeneste og begynner å innlemme en database, cache, frontend og andre mikrotjenester, blir det et skikkelig ork å administrere alt dette manuelt. Det er her Docker Compose kommer inn i bildet, et verktøy som er designet nettopp slik at du ikke trenger å starte container for container, konfigurere nettverk manuelt eller huske hver eneste lange kommando.

Målet med denne artikkelen er at du skal lære hvordan du distribuerer komplette applikasjoner med Docker Compose.Dette kurset vil dekke både lokale og serverbaserte applikasjoner, og sikre at du fullt ut forstår funksjonen til hver del av docker-compose.yml-filen, hvordan tjenester, volumer og nettverk fungerer, kommandoene du trenger daglig, og hvordan alt dette passer inn i en virkelig kontekst med en Node.js-app og en database. Hvis du kommer fra en ren utviklingsbakgrunn (frontend, mobil, backend) og konsepter som orkestrering og drift høres ut som tull, ikke bekymre deg: vi går trinn for trinn, men uten å spare på detaljene.

Grunnleggende miljøkrav

Før vi begynner å distribuere noe, trenger du et minimalt forberedt basissystem.Et typisk og vanlig brukt miljø for øving og små produksjonsprosjekter kan se omtrent slik ut:

• Ubuntu 20.04 som serveroperativsystem eller lokal maskin.
• Docker 20.10.x installert og fungerer (daemonen er aktiv).
• Docker Compose 1.29.x eller høyere å administrere prosjekter med flere containere.
• Node.js 18.x y NPM 8.x hvis du skal bygge bilder fra et Node-program.

Det er ikke obligatorisk å bruke akkurat disse versjonene.men har noe lignende og relativt nytt. På skyservere som VPS (Google Cloud, AWS, Arsys, osv.) er vanlig praksis å sette opp en virtuell maskin LinuxInstaller Docker, og legg deretter til Docker Compose på toppen av det.

Hva er Docker, og hva løser Docker Compose?

Docker er en plattform for pakking og kjøring av applikasjoner i isolerte containereHver container inneholder bare det som trengs for å kjøre prosessen din (binærfiler, biblioteker, runtime osv.), og deler kjernen med verten, men uten å forstyrre andre tjenester. Dette eliminerer det klassiske "det fungerer på min maskin"-dilemmaet og lar deg flytte appen sømløst mellom forskjellige maskiner.

Docker Compose, derimot, er verktøyet som orkestrerer flere containere som om de var én enkelt applikasjon.Hvis du bare hadde en enkel tjeneste, kunne du klare deg med Docker Run, men så snart du trenger:

• Un frontend (Angular, React, Vue…)
• Un backend (Node.js, Java, Python…)
• en database (MySQL, PostgreSQL, MongoDB…)
• Kanskje en cache system Redis-typen

Å administrere alt dette container for container blir upraktisk.Med Compose kan du definere hele «stakken» i én YAML-fil, og deklarere hvilke tjenester som finnes, hvordan de kobler seg til, hvilke porter de eksponerer, hvilke volumer de bruker og hvilke miljøvariabler de trenger.

Den filen kalles vanligvis docker-compose.ymlSelv om det kan kalles noe annet hvis du spesifiserer det med -f når du kjører kommandoene. Det fungerer som en oppskrift: alle med Docker og Docker Compose kan replikere den samme containerinfrastrukturen på sin maskin eller server.

Installere Docker Compose på forskjellige systemer

Den eneste forutsetningen for å installere Docker Compose er at Docker kjører.Derfra endres prosessen litt avhengig av operativsystemet:

Installasjon på Linux (for eksempel Ubuntu)

På distribusjoner som Ubuntu kan du installere Docker Compose ved å laste ned den offisielle binærfilen. og gi den utførelsestillatelser. Et typisk mønster er:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" \
  -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

Når dette er gjort, kjør docker-compose --version for å bekrefte at kommandoen er tilgjengelig og svarer med riktig versjon.

Installasjon på macOS

En Mac Den enkleste måten er vanligvis å installere Docker Desktop.som allerede har Docker Engine og Docker Compose integrert. Alternativt bruker mange utviklere Homebrew:

brew install docker-compose

Med Docker Desktop trenger du vanligvis ikke lenger å bekymre deg for komposisjoner.fordi pakken selv sørger for å holde den oppdatert sammen med Docker-motoren.

Installasjon på Windows

En Windows Den mest praktiske løsningen er å bruke Docker Desktop for Windows.. Nedlastinger Kjør installasjonsprogrammet fra det offisielle Docker-nettstedet og følg veiviseren. Dette vil gjøre både Docker og Compose klare. PowerShell eller i WSL2.

Selv om det er mulig å jobbe med Docker på native Windows-versjonerFor mer seriøse utviklingsmiljøer anbefales det vanligvis å bruke WSL2 med en Linux-distribusjon eller direkte en ekstern Linux VM, der Docker og Compose jobber nærmere produksjon.

Grunnleggende struktur av en docker-compose.yml

Innenfor docker-compose.yml-filen kan vi definere flere hovedblokkerDette inkluderer formatversjon, tjenester, volumer, nettverk og i noen tilfeller tilleggskonfigurasjoner. Tjenester er viktige for å distribuere en typisk app, og volumer og nettverk er nødvendige for vedvarende distribusjon.

Tjenester: hjertet i appen

Hver tjeneste i Compose-filen tilsvarer vanligvis en container (eller gruppe containere) som leverer en del av applikasjonen.For eksempel en webtjeneste, en databasetjeneste, en hurtigbuffertjeneste osv. Definisjonen av hver tjeneste støtter en rekke egenskaper, blant hvilke følgende skiller seg ut:

• bildeDocker-avbildning som skal brukes for containeren (for eksempel nginx:latest, postgres:15, node:18…).
• beholdernavnEksplisitt beholdernavn (valgfritt; hvis ikke definert, genererer Compose et).
• bygge: sti til katalogen der Dockerfile ligger for å bygge bildet hvis det ikke finnes eller vi ønsker et tilpasset et.
• kommando: kommando som vil bli utført når containeren starter (overskriver CMD (fra bildet).
• porterporttilordning i host:container-format, for eksempel «80:80» eller «3030:3030».
• volumervolummonteringer (navngitte volumer, bindingsmonteringer osv.).
• miljømiljøvariabler som injiseres i beholderen.
• kommer an på: indikerer avhengigheter mellom tjenester, slik at noen starter før andre.
• nettverkDocker-nettverk som tjenesten kobler seg til.
• restart: omstartspolicy (nei, alltid, ved feil, med mindre stoppet).

Det som er interessant er at mange av disse egenskapene er valgfrie.Du kan definere en tjeneste ved å bare bruke `image`, og Compose vil da kunne starte containeren med standardverdier. Deretter kan du finjustere porter, nettverk, variabler osv. etter behov.

Volumer: Datapersistens og deling

Volumer i Docker er standardmekanismen for å lagre data og dele dem mellom containere eller med verten.I Compose blir de vanligvis deklarert i «volumer»-delen på rotnivå, og deretter referert til fra tjenestene.

Et volum kan ha flere relevante egenskaper.:

• sjåførvolumdrivertype (standard, lokal).
• driver_optsspesifikke driveralternativer, der du kan spesifisere:
  • typenvolumtype («volum», «binding», «nfs» osv.).
  • enhet: banen på verten du vil montere, i tilfelle en bindingsmontering.
  • omonteringsalternativer (rw, ro, osv.).
• utvendig: hvis volumet administreres eksternt (ikke opprettet av Compose).
• etiketter: vilkårlige etiketter.
• navn: volumnavn, hvis du vil tilpasse det.
• omfangvolumomfang (vanligvis lokalt).

Selv om du kan konfigurere mange detaljer, er det i mange tilfeller nok å deklarere volumnavnet og bruk den i tjenesten. For eksempel, for en MySQL- eller PostgreSQL-database er det vanlig å ha et datavolum og noen ganger en bindingsmontering for initialiseringsskript.

Nettverk: kommunikasjon mellom containere

Når et program har flere moduler, vil du vanligvis isolere trafikken på et internt nettverk. slik at frontend og backend, eller backend og database, bare kan se hverandre og ikke er ukontrollert eksponert for verten.

Docker implementerer nettverk med en trelagsinspirert modell:

• Endpoint: det virtuelle grensesnittet som kobler containeren til nettverket.
• sandkasse: containerens isolerte nettverksrom (dens egen TCP/IP-stabel).
• Networknettverket som forbinder de forskjellige sandkassene gjennom endepunktene.

Blant de drivere De vanligste nettverkskomponentene i Docker er:

Driver	Ambit	beskrivelse
bro	lokal	Det er standardnettverket på mange Docker-verter, og oppretter en virtuell bro på verten og kobler containere til hverandre.
vert	lokal	Deaktiver nettverksisolering: beholderen deler vertens nettverk direkte.
overlegg	Global	Den lar deg koble til containere som kjører på forskjellige Docker-verter i en sverm.
macvlan	Global	Tilordne en MAC-adresse til containeren som om den var en fysisk enhet på nettverket.
none	lokal	Uten Docker-administrert nettverkstilkobling, i svært spesifikke tilfeller.

I Compose defineres nettverk i delen «nettverk».Det er her du velger driveren og alternativene. Hvis du ikke definerer noe, brukes vanligvis et bronettverk som standard. Tjenester kobler seg til disse nettverkene ganske enkelt ved å oppgi navnet i definisjonen.

Enkelt eksempel: nginx og PostgreSQL med Docker Compose

For å sette alle disse konseptene i perspektiv, tenk deg at du vil bygge et enkelt nettsted med Nginx og en PostgreSQL-database.Et minimalistisk eksempel på docker-compose.yml kan inkludere to tjenester, et internt nettverk og et par volumer:

version: '3.8'

services:
  web:
    image: nginx:latest
    container_name: mi_nginx
    ports:
      - "80:80"
    depends_on:
      - db
    networks:
      - app_net

  db:
    image: postgres:latest
    container_name: mi_postgres
    environment:
      POSTGRES_PASSWORD: ejemplo_password
    volumes:
      - datos_db:/var/lib/postgresql/data
    networks:
      - app_net

volumes:
  datos_db:

networks:
  app_net:
    driver: bridge

Her ser vi to svært viktige tingPå den ene siden eksponerer Nginx port 80 for verten mens databasen bare er tilgjengelig innenfor app_net-nettverket, og på den andre siden lagres PostgreSQL-dataene på et volum kalt datos_db. Videre er web avhengig av db, så Compose vil forsøke å starte databasen først.

Avhengigheter mellom tjenester med depends_on

I en applikasjon i den virkelige verden er det ofte sammenhenger av "denne tjenesten gir ingen mening uten den".For eksempel et REST API som trenger at databasen kjører for å initialisere tilkoblinger, eller et frontend som bare starter når backend svarer.

I Docker Compose kan du uttrykke disse relasjonene med depends_on-nøkkelen., som viser tjenestene som den nåværende er avhengig av:

services:
  api:
    image: mi_usuario/mi_api:latest
    depends_on:
      - db

  db:
    image: postgres:15

Med denne konfigurasjonen, når du kjører docker-compose uten å spesifisere tjenester,Compose laster først databasen, og deretter API-et. Husk imidlertid at `depends_on` styrer rekkefølgen på operasjonene. bootDet garanterer imidlertid ikke 100 % at den avhengige tjenesten er «klar» (for eksempel at databasen godtar tilkoblinger). I kritiske tilfeller brukes vanligvis venteskript eller helsesjekker.

Viktige Docker Compose-kommandoer

Når du har docker-compose.yml-filen på plassDaglig bruk av Compose dreier seg om noen viktige kommandoer. Vi antar alltid at du er i katalogen der filen ligger, eller at du bruker -f-alternativet for å indikere dette.

Start applikasjonen: docker-compose up

Hovedkommandoen for å distribuere containerne er docker-compose upHvis du kjører den uten ytterligere parametere, vil den forsøke å bygge de nødvendige bildene (hvis de har en byggeseksjon) og starte alle de definerte tjenestene:

docker-compose up

Hvis du vil at containerne skal kjøre i bakgrunnen, som vanlig på servere, legg til -d:

docker-compose up -d

Stopp containere: docker-compose down

For å stoppe og slette prosjektbeholdere (men ikke nødvendigvis bilder eller volumer) du bruker:

docker-compose down

Du kan kombinere denne kommandoen med flere alternativer. Hvis du vil slette volumer, egendefinerte nettverk osv., kan du også gjøre det, men i de fleste tilfeller er det nok å bare bruke `down` for å stoppe prosjektet på en ordnet måte.

Se statusen til tjenestene: docker-compose ps

Hvis du trenger å sjekke hvilke tjenester som er aktive, hvilke porter de har tilordnet og statusen deres, kommandoen som skal brukes er:

docker-compose ps

Dette vil vise deg en tabell med containerne som administreres av den Compose., inkludert kolonner for navn, bilde, porter og gjeldende status, veldig nyttig for å bekrefte at alt er som forventet.

Spørringslogger: docker-compose-logger

For å se hva som skjer i tjenestene dine, kan du bruke docker-compose-logger.Du kan se loggene for alle tjenester eller for en bestemt tjeneste:

docker-compose logs

# Sólo los logs del servicio "api"
docker-compose logs api

Hvis du legger til -f-alternativet, vil du spore i sanntid (ligner på tail -f):

docker-compose logs -f api

Gå inn i en container: docker-compose exec

Når du trenger å "komme inn i" en container for å feilsøke eller kjøre kommandoerDu bruker `docker-compose exec`. For eksempel, for å åpne et skall i en tjeneste kalt `api`:

docker-compose exec api sh

I containere basert på bash-distribusjoner Du kan bruke bash i stedet for sh, avhengig av hva som er mest praktisk avhengig av basisbildet.

Bygg eller gjenoppbygg bilder: docker-compose build og docker-compose pull

Hvis du har endret en Dockerfil eller deler av byggekontekstenDu må rekonstruere de tilhørende bildene:

docker-compose build
# O bien para un servicio concreto
docker-compose build api

Når bildene kommer fra et eksternt register (Docker Hub, privat register...) Og hvis du bare vil laste ned den nyeste versjonen som er deklarert i YAML, bruker du:

docker-compose pull

Husk at du alltid kan ty til «vanlige» Docker-kommandoer. (docker ps, docker-bilder, docker-volum ls, docker-nettverk ls, osv.), men for å opprettholde prosjektkonsistens er det bedre å håndtere alt som påvirker tjenestene som er definert i docker-compose.yml via Compose.

Komplett eksempel: Node.js + MySQL-app med Docker og Docker Compose

La oss nå se på et litt mer realistisk eksempel.Et REST API i Node.js som bruker MySQL til å lagre informasjon (for eksempel bildata). Den typiske flyten ville være:

1. Utvikle API-et bruk av miljøvariabler for konfigurasjon.
2. Opprett en Dockerfile for API-et.
3. Bygg og last opp bildet til Docker Hub hvis du vil..
4. Definer en docker-compose.yml med API-et og databasen.
5. Få alt opp og går med docker-compose og prøv appen.

1. Node.js API klargjort for miljøvariabler

Anta at du har et Node-prosjekt med Express som eksponerer noen endepunkter For å spørre, opprette og liste opp biler. Nøkkelen her er ikke selve koden, men snarere at konfigurasjonen av databasetilkoblingen kommer fra miljøvariabler som DB_HOST, DB_USER, DB_PASSWORD, DB_NAME osv.

Dette er viktig for å fungere godt med Docker.Du ønsker ikke å brenne legitimasjonsinformasjon eller URL-er inn i koden, men heller parameterisere den ved distribusjonstidspunktet, enten lokalt eller i skyen.

2. Dockerfile for webapplikasjonen

Inne i appkatalogen oppretter du en Dockerfile som er ansvarlig for å bygge imagetEt grunnleggende eksempel kan være:

FROM node:18-alpine

WORKDIR /usr/src/app

COPY package*.json ./
RUN npm install --only=production

COPY . .

EXPOSE 3000

CMD ["node", "index.js"]

Denne Dockerfilen er basert på et offisielt Node-bildeInstaller avhengigheter, kopier koden, eksponer appens port (3000 i dette tilfellet), og definer oppstartskommandoen. Herfra kan du bygge imaget lokalt.

docker build -t mi_usuario/mi-api-coches:latest .

Bekreft at bildet finnes ved hjelp av docker-bilder Og hvis alt går bra, kan du til og med kjøre det API-et i en separat container ved hjelp av Docker Run. Men den interessante delen kommer når vi orkestrerer det med databasen ved hjelp av Compose.

3. Last opp bildet til en post (valgfritt, men veldig nyttig)

Hvis du vil kunne distribuere appen din på en annen maskin (for eksempel en virtuell maskin i skyen)Det er veldig praktisk å laste opp bildet til Docker Hub eller et annet register. Slik gjør du dette:

docker login
# te pedirá usuario y contraseña

docker push mi_usuario/mi-api-coches:latest

Hvis du vil eksplisitt versjonereDu kan merke flere versjoner:

docker tag mi_usuario/mi-api-coches:latest mi_usuario/mi-api-coches:v1

docker push mi_usuario/mi-api-coches:v1

På serveren der du skal distribuereDet vil være nok å gjøre en docker-pull av bildet og bruke det i docker-compose.yml, uten å måtte bygge det opp igjen der.

4. Definer docker-compose.yml med API og MySQL

Neste trinn er å opprette en docker-compose.yml-fil som kombinerer API-et og databasen.også legge til et volum for MySQL-dataene og, om nødvendig, en script initialisering:

version: '3.8'

services:
  web:
    image: mi_usuario/mi-api-coches:latest
    container_name: api_coches
    ports:
      - "3000:3000"
    environment:
      DB_HOST: db
      DB_USER: coches_user
      DB_PASSWORD: coches_pass
      DB_NAME: coches_db
    depends_on:
      - db
    networks:
      - coches_net

  db:
    image: mysql:8
    container_name: mysql_coches
    environment:
      MYSQL_ROOT_PASSWORD: root_pass
      MYSQL_DATABASE: coches_db
      MYSQL_USER: coches_user
      MYSQL_PASSWORD: coches_pass
    volumes:
      - datos_mysql:/var/lib/mysql
      - ./initdb:/docker-entrypoint-initdb.d
    ports:
      - "3306:3306"
    networks:
      - coches_net

volumes:
  datos_mysql:

networks:
  coches_net:
    driver: bridge

Det er flere interessante detaljer i denne konfigurasjonen.:

• API-et peker til databasen ved hjelp av DB_HOST=dbsom samsvarer med MySQL-tjenestenavnet. Docker Compose tilbyr en intern DNS, så du trenger ikke å bekymre deg for IP-adresser; bare bruk tjenestenavnet.
• ./initdb-mappen er montert på /docker-entrypoint-initdb.d i MySQL-containeren.Dette lar deg inkludere .sql- eller .sh-skript som kjører automatisk ved første oppstart (for eksempel for å opprette tabeller, sette inn eksempeldata osv.).
• MySQL-data lagres i data_mysql-volumetSå hvis du dumper containerne med docker-compose, forblir databaseinformasjonen intakt.
• Begge tjenestene deler coches_net-nettverket.som fungerer som et isolert internt nettverk. Utad eksponerer du bare de portene du ønsker (3000 for API-et, 3306 hvis du trenger tilgang til databasen utenfra, noe som noen ganger ikke engang er nødvendig).

5. Implementer og test applikasjonen

Med docker-compose.yml klar, er det like enkelt å distribuere den som å starte den. fra filkatalogen:

docker-compose up -d

Første gang vil ta litt lengre tid Fordi den må laste ned MySQL-bildene (og API-et hvis det ikke er lokalt), opprette volumet og kjøre initialiseringsskriptene. Deretter, for å sjekke statusen:

docker-compose ps

Hvis alt er i orden, kan du begynne å sende forespørsler til API-et fra krøll eller Postmann. For eksempel:

# Listar todos los coches
curl http://localhost:3000/coches

# Obtener un coche concreto
curl http://localhost:3000/coches/1

# Crear un coche vía POST
curl -X POST http://localhost:3000/coches \
  -H "Content-Type: application/json" \
  -d '{"marca": "Seat", "modelo": "León"}'

Når du vil avslutte utrullingen, kjører du ganske enkelt `docker-compose down`.Hvis du ikke sletter volumet, vil dataene bli beholdt til neste oppstart.

Implementering av Docker Compose på skyservere og Portainer

Alt vi har sett gjelder like mye for utrulling på din egen bærbare datamaskin som på en skyserver.Forskjellen er i bunn og grunn hvor du kjører docker-compose up-kommandoene og hvordan du åpner portene utover.

En veldig enkel tilnærming for personlige prosjekter eller sideprosjekter Det innebærer å opprette en liten virtuell maskin (for eksempel en gratis e2-micro på Google Cloud), installere Docker og Docker Compose, klone depotet ditt med koden og docker-compose.yml-filen, og starte appen der.

Det eneste du må huske på er leverandørens brannmurpolicy.Hvis appen din lytter på port 3000, må du åpne den porten i internettleverandørens nettverksinnstillinger (eller bruke en omvendt proxy på port 80/443 hvis du vil være ekstra sikker med HTTPS). Når porten er åpen, kan du få tilgang til den ved å bruke http://SERVER_IP:3000 fra hvilken som helst nettleser.

Hvis det er for tungvint for deg å administrere containere via konsollen, kan du bruke Portainer.Portainer er et verktøy som også kjører i en container og tilbyr et webgrensesnitt for å administrere Docker (og Docker Compose). For å sette opp Portainer på en server trenger du ganske enkelt å gjøre noe slikt som:

docker volume create portainer_data

docker run -d \
  -p 8000:8000 -p 9000:9000 \
  --name=portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer

Da får du tilgang til Portainer på http://SERVER_IP:9000Du ville opprettet en administratorbruker, og derfra kunne du se containere, komponere stabler, nettverk, volumer osv., alt fra nettleseren.

Ved å jobbe med Docker Compose kan du innkapsle hele arkitekturen til et program i én enkelt fil.Dette gjør det enkelt for enhver utvikler, fra sin bærbare datamaskin eller en ekstern virtuell maskin, å starte den samme stakken med én kommando. Ved å legge til beste praksis som bruk av miljøvariabler, interne nettverk, vedvarende volumer og, om nødvendig, verktøy som Portainer, har du et solid grunnlag for å distribuere alt fra små personlige prosjekter til ganske seriøse miljøer uten å gå deg vill.