Komplett guide til distribusjon av applikasjoner med Docker Compose

Siste oppdatering: 13/01/2026
Forfatter: Isaac
  • Docker Compose lar deg definere og orkestrere applikasjoner med flere containere ved hjelp av en YAML-fil, noe som forenkler komplekse distribusjoner.
  • Tjenester, nettverk og volumer beskrives deklarativt, noe som legger til rette for datapersistens og sikker intern kommunikasjon.
  • kommandoer som opp, ned, logger, exec og build dekker hele livssyklusen til prosjekter som administreres med Compose.
  • Én enkelt docker-compose.yml-fil gjør utrullingen reproduserbar både lokalt og på skyservere eller VPS administrert via konsoll eller Portainer.

Distribuere applikasjoner med Docker Compose

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

Målet med denne artikkelen er at du skal lære hvordan du distribuerer komplette applikasjoner med Docker Compose , både lokalt og på servere, ved å forstå hva hver del av docker-compose.yml-filen gjør, hvordan tjenester, volumer og nettverk fungerer, hvilke kommandoer du trenger i ditt daglige arbeid, og hvordan alt dette passer inn i en virkelig kontekst med en Node.js-app og en database. Hvis du kommer fra ren utvikling (frontend, mobil, backend) og konsepter som orkestrering eller 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 som helst, trenger du et minimalt forberedt basissystem . Et typisk miljø, som vanligvis brukes til ø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 det anbefales å ha noe lignende og relativt nytt. På skyservere som VPS ( Google Cloud, AWS, Arsys osv.) er vanlig praksis å sette opp en Linux VM , installere Docker og deretter legge til Docker Compose i tillegg.

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

Docker- og Compose-konseptene

Docker er en plattform for pakking og kjøring av applikasjoner i isolerte containere . Hver 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. Det eliminerer det klassiske "det fungerer på min maskin"-dilemmaet og lar deg flytte appen din 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

Det blir upraktisk å administrere alt dette container for container . Compose lar deg definere hele "stakken" i en enkelt 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.yml , selv om den kan navngis med noe annet hvis du spesifiserer det med -f når du kjører kommandoene. Det fungerer som en oppskrift: alle som har Docker og Docker Compose kan replikere den samme containerinfrastrukturen på maskinen eller serveren sin.

Installere Docker Compose på forskjellige systemer

Installer Docker Compose

Den eneste forutsetningen for å installere Docker Compose er at Docker kjører . Derfra varierer prosessen noe 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øringstillatelser. 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

På Mac er den enkleste måten vanligvis å installere Docker Desktop , som allerede inkluderer Docker Engine og Docker Compose. 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

På Windows er det mest praktiske alternativet å bruke Docker Desktop for Windows . Last ned installasjonsprogrammet fra det offisielle Docker-nettstedet, kjør det og følg veiviseren. Dette vil gjøre både Docker og Compose klare i PowerShell eller WSL2.

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

Grunnleggende struktur av en docker-compose.yml

Docker Compose-filstruktur

Innenfor docker-compose.yml-filen kan vi definere flere hovedblokker : formatversjon, tjenester, volumer, nettverk og i noen tilfeller ekstra konfigurasjoner. Tjenester er viktige for å distribuere en typisk app, og volumer og nettverk er avgjørende når du trenger utholdenhet.

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, inkludert:

  • 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).
  Selvhosting av Bitwarden: en komplett guide til å sette opp din egen server

Det interessante er at mange av disse egenskapene er valgfrie . Du kan definere en tjeneste ved å bare bruke `image`, og Compose ville allerede 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 deklareres de vanligvis i "volumer"-delen på rotnivå og refereres deretter til av tjenester.

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 bruke det 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 en applikasjon har flere moduler, er det vanlig å ønske å isolere trafikken på et internt nettverk, slik at frontend og backend, eller backend og database, bare kan se hverandre og ikke eksponeres ukontrollert 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 vanligste nettverksdriverne i Docker har vi :

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» , der 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

Eksempel på distribusjon med Docker Compose

For å illustrere disse konseptene, tenk deg at du vil sette opp 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 ting : for det første, at Nginx eksponerer port 80 for verten mens databasen bare er tilgjengelig innenfor app_net-nettverket, og for det andre, at PostgreSQL-dataene lagres 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 finnes det ofte relasjoner der «denne tjenesten er meningsløs 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 nøkkelen depends_on , som viser tjenestene som den gjeldende 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 up` uten å spesifisere services , vil Compose starte databasen først, og deretter API-et. Husk imidlertid at `depends_on` kontrollerer oppstartsrekkefølgen , men det garanterer ikke at den avhengige tjenesten allerede er "klar" (for eksempel at databasen godtar tilkoblinger). I kritiske tilfeller brukes vanligvis venteskript eller helsesjekker.

  Praktiske eksempler på FFmpeg-kommandoer for konvertering av formater på Linux

Viktige Docker Compose-kommandoer

Når du har docker-compose.yml-filen på plass , dreier den daglige bruken av Compose seg om noen få 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 containere er `docker-compose up` . Hvis du kjører den uten andre parametere, vil den forsøke å bygge de nødvendige avbildningene (hvis de har en `build`-seksjon) og starte alle de definerte tjenestene.

docker-compose up

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

docker-compose up -d

Stopp containere: docker-compose down

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

docker-compose down

Du kan kombinere denne kommandoen med tilleggsalternativer hvis du også vil slette volumer, tilpassede nettverk osv., 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 er tilordnet til, og statusen deres , er kommandoen du skal bruke:

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 logs` . Du kan se logger 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 kommandoer , bruker du `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 kan du bruke bash i stedet for sh, avhengig av hva som er mest praktisk avhengig av basisimaget.

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

Hvis du har endret Dockerfiler eller deler av byggekonteksten , må du gjenoppbygge de tilhørende bildene:

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

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

docker-compose pull

Husk at du alltid kan bruke de "vanlige" Docker-kommandoene (docker ps, docker images, docker volume ls, docker network ls, osv.), men for å opprettholde prosjektkonsistens er det best å håndtere alt som påvirker tjenestene definert i docker-compose.yml via Compose.

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

La oss se på et 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ørring, oppretting 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 grunnleggende 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

I appens katalog oppretter du en Dockerfile som skal håndtere byggingen av imaget . Et 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 starter med et offisielt Node-bilde , installerer avhengigheter, kopierer koden, eksponerer appens port (3000 i dette tilfellet) og definerer oppstartskommandoen. Herfra kan du bygge bildet lokalt:

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

Bekreft at bildet finnes ved hjelp av `docker images` , og hvis alt fungerer som det skal, 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 skymaskin) , er det veldig praktisk å laste opp avbildningen 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 versjonere eksplisitt , kan du 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 distribuere , trenger du bare å gjøre en docker-pull av imaget og bruke det i docker-compose.yml, uten å måtte gjenoppbygge det 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 , og som også legger til et volum for MySQL-dataene og, om nødvendig, et initialiseringsskript :

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).
  Omarchy: DHHs forpliktelse til et finjustert Arch + Hyprland

5. Implementer og test applikasjonen

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

docker-compose up -d

Første gang vil det 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 API-forespørsler fra curl eller Postman. 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 bevart 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 mot omverdenen.

En veldig enkel tilnærming for personlige prosjekter eller sideprosjekter er å lage 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, 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 leverandø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 føles tungvint å administrere containere via kommandolinjen, kan du bruke Portainer , 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, gjør du ganske enkelt noe slikt:

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

Deretter ville du få tilgang til Portainer på http://SERVER_IP:9000 , opprette en administratorbruker, og derfra kunne du se containere, Compose-stabler, nettverk, volumer osv., alt fra nettleseren.

Ved å bruke Docker Compose kan du innkapsle hele arkitekturen til et program i én fil , noe som gjør det enkelt for enhver utvikler, fra den bærbare datamaskinen 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 i prosessen.

Isaac

Isaac

Lidenskapelig forfatter om verden av bytes og teknologi generelt. Jeg elsker å dele kunnskapen min gjennom å skrive, og det er det jeg skal gjøre i denne bloggen, vise deg alle de mest interessante tingene om dingser, programvare, maskinvare, teknologiske trender og mer. Målet mitt er å hjelpe deg med å navigere i den digitale verden på en enkel og underholdende måte.