Kuinka asentaa ja käyttää Docker Composea Ubuntulla

Johdanto

Docker yksinkertaistaa sovellusprosessien hallintaa konteissa. Vaikka kontit muistuttavat tietyiltä osin virtuaalikoneita, ne ovat kevyempiä ja vähemmän resursseja kuluttavia. Tämä antaa kehittäjille mahdollisuuden jakaa sovellusympäristö useisiin eristettyihin palveluihin.

Sovelluksille, jotka riippuvat useista palveluista, kaikkien konttien käynnistämisen, kommunikoinnin ja samanaikaisen sulkemisen orkestrointi voi nopeasti muuttua vaikeaksi hallita. Docker Compose on työkalu, joka mahdollistaa monikonttisovellusympäristöjen ajamisen YAML-tiedostoon määriteltyjen määritysten perusteella. Se käyttää palvelumääritelmiä rakentaakseen täysin mukautettavia ympäristöjä, joissa voi olla useita kontteja, jotka voivat jakaa verkkoja ja tietovarastoja.

Tämä opas opastaa sinut Docker Composen asentamiseen Ubuntu-palvelimelle ja yksinkertaisen kontin ajamiseen. Sen jälkeen opit rakentamaan monipalveluympäristön käyttäen WordPress-sovellusta ja MySQL-tietokantaa. Käsittelemme myös edistyneempiä aiheita, kuten palveluiden skaalaamista, mukautettujen verkkojen määrittämistä ja modulaaristen include-direktiivien käyttöä. Lopuksi artikkeli tarjoaa ohjeet siirtymiseen vanhemmasta docker-compose (v1) versiosta nykyaikaiseen docker compose (v2) versioon sekä yksityiskohtaisen osion yleisten ongelmien, kuten porttikonfliktien ja käyttöoikeusvirheiden, ratkaisemisesta.

Edellytykset

Seurataksesi tätä artikkelia tarvitset:

• Pääsy Ubuntu-local-koneelle tai kehityspalvelimelle ei-root -käyttäjänä, jolla on sudo-oikeudet. Jos käytät etäpalvelinta, on suositeltavaa, että siinä on aktiivinen palomuuri. Näiden asentamiseksi, katso ohjeet alkuperäisestä palvelimen asennusoppaastamme Ubuntua varten.
• Docker on asennettuna palvelimellesi tai paikalliselle koneellesi, seuraamalla Vaiheet 1 ja 2 ohjeesta Kuinka asentaa Docker Ubuntuun – askel askeleelta -opas.

Vaihe 1 — Docker Composen asentaminen

Ubuntuun on kaksi tapaa asentaa Docker Compose:

• Asenna käyttämällä arkistoa
• Asenna manuaalisesti

Käsittelemme molempia tapoja tässä osiossa.

Docker Compose -asennus apt-arkiston avulla

Ensiksi, asennetaan Dockerin apt-varasto.

# Add Docker's official GPG key:

sudo apt-get update

sudo apt-get install ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc



# Add the repository to Apt sources:

echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \

  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \

  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Nyt voit asentaa Docker Composen käyttämällä seuraavaa komentoa:

sudo apt install docker-compose-plugin

Docker Compose on nyt asennettu järjestelmääsi onnistuneesti. Varmistaaksesi, että asennus onnistui, voit suorittaa:

docker compose version

Näet samankaltaisen tuloksen kuin tämä:

Docker Compose version v2.3.3

Docker Composen asentaminen käsin

Varmistaaksesi, että saat Docker Composen uusimman vakaan version, lataat tämän ohjelmiston sen virallisesta Github-repositoriosta.

Varmista ensin uusin saatavilla oleva versio heidän julkaisusivultaan. Tämän kirjoitushetkellä uusin vakaa versio on v2.40.2.

Käytä seuraavaa komentoa ladataksesi:

mkdir -p ~/.docker/cli-plugins/

curl -SL https://github.com/docker/compose/releases/download/v2.40.2/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose

Seuraavaksi aseta oikeat käyttöoikeudet, jotta docker compose -komento voidaan suorittaa:

chmod +x ~/.docker/cli-plugins/docker-compose

Seuraavassa osiossa näet, kuinka luodaan docker-compose.yml -tiedosto ja käynnistetään konttien ympäristö tämän työkalun avulla.

Vaihe 2 — docker-compose.yml-tiedoston luominen

Näyttääksemme, kuinka docker-compose.yml -tiedosto asetetaan ja miten Docker Composea käytetään, luot verkkopalvelinympäristön käyttäen virallista Nginx-kuvaa Docker Hubista, julkisesta Docker-rekisteristä. Tämä konttien ympäristö palvelee yhtä staattista HTML-tiedostoa.

Aloita luomalla uusi kansio kotikansioosi ja siirry sitten siihen:

mkdir ~/compose-demo

cd ~/compose-demo

Tässä hakemistossa luo sovelluskansio, joka toimii Nginx-ympäristösi dokumenttijuurena:

mkdir app

Käyttäen suosikkitekstieditoriasi, luo uusi index.html-tiedosto app-kansioon:

nano app/index.html

Aseta seuraava sisältö tähän tiedostoon:

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>

Tallenna ja sulje tiedosto, kun olet valmis. Jos käytät nanoa, voit tehdä sen painamalla CTRL+X, sitten Y ja ENTER vahvistaaksesi.

Seuraavaksi luo docker-compose.yml-tiedosto:

nano docker-compose.yml

Lisää seuraava sisältö docker-compose.yml -tiedostoosi:

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html

Nykyisessä Docker Composessa version-kenttä on valinnainen ja usein jätetään pois, koska Compose voi automaattisesti tunnistaa konfiguraation version. Edellä oleva esimerkki ei sisällä version-kenttää, mikä on suositeltu lähestymistapa useimmille uusille projekteille. version-kenttä täytyy määrittää vain yhteensopivuuden vuoksi vanhempien versioiden kanssa.

Sitten sinulla on services-lohko, jossa määritetään tämän ympäristön osaksi kuuluvat palvelut. Tapauksessasi sinulla on yksi palvelu nimeltä web. Tämä palvelu käyttää nginx:alpine-kuvaa ja asettaa porttien uudelleenohjauksen ports-direktiivillä. Kaikki portin 8000 pyynnöt isäntäkoneessa (järjestelmä, josta Docker Composea ajetaan) ohjataan web-konttiin portissa 80, jossa Nginx tulee olemaan käynnissä.

volumes-direktiivi luo jaetun volumet isäntäkoneen ja kontin välille. Tämä jakaa paikallisen app-kansion kontin kanssa, ja volume sijaitsee kontin sisällä polussa /usr/share/nginx/html, mikä korvaa Nginxin oletusdokumenttijuuren.

Tallenna ja sulje tiedosto.

Olet luonut demoversion sivusta ja docker-compose.yml-tiedoston luodaksesi kontitetun verkkopalvelinympäristön, joka palvelee sitä. Seuraavassa vaiheessa käynnistät tämän ympäristön Docker Composen avulla.

Vaihe 3 — Docker Composen suorittaminen

Kun docker-compose.yml -tiedosto on paikallaan, voit nyt suorittaa Docker Composea käynnistääksesi ympäristösi. Seuraava komento lataa tarvittavat Docker-kuvat, luo konttinalustan web-palvelulle ja suorittaa konttien ympäristön taustatilassa:

docker compose up -d

Docker Compose etsii ensin määriteltyä imagea paikalliselta järjestelmältäsi, ja jos se ei löydä imagea, se lataa sen Docker Hubista. Näet tällaisen tulosteen:

Creating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done

sudo usermod -aG docker ${USER}

Tämän komennon suorittamisen jälkeen sinun täytyy kirjautua ulos ja takaisin sisään, jotta ryhmämuutokset tulevat voimaan. Voit myös ottaa muutokset käyttöön nykyisessä komentorivisessiossa kirjoittamalla:

newgrp docker

Tämä komento korjaa mahdolliset oikeusvirheet, jotka liittyvät Docker-sokkeliin. Täydellisen ohjeistuksen saat katselemalla Vaihe 2 ohjeesta Kuinka asentaa Docker Ubuntulle – askel askeleelta -opas.

Ympäristösi on nyt käynnissä taustalla. Tarkistaaksesi, että kontti on aktiivinen, voit suorittaa:

docker compose ps

Tämä komento näyttää tietoja käynnissä olevista kontteista ja niiden tilasta sekä kaikista tällä hetkellä käytössä olevista porttien uudelleenohjauksista:

       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Voit nyt käyttää demoesovellusta osoittamalla selaimesi joko localhost:8000, jos suoritat tätä demoa paikallisella koneellasi, tai palvelimesi_verkko_osoite_tai_IP:8000, jos suoritat tätä demoa etäpalvelimella.

Näet sivun, joka näyttää tältä:

Jakamasi tallennustila, jonka olet määrittänyt docker-compose.yml-tiedostossa, pitää app-kansion tiedostot synkronoituna kontin dokumenttijuuren kanssa. Jos teet muutoksia index.html-tiedostoon, ne otetaan automaattisesti käyttöön kontissa ja näkyvät siten selaimessasi, kun päivität sivun.

Seuraavassa vaiheessa näet, kuinka hallita konttien ympäristöäsi Docker Compose -komennoilla.

Vaihe 4 — Docker Compose -komentojen tuntemuksiin tutustuminen

Olet nähnyt, kuinka docker-compose.yml-tiedosto asetetaan ja kuinka ympäristö käynnistetään komennolla docker compose up. Nyt näet, kuinka Docker Compose -komentoja käytetään hallitsemaan ja vuorovaikuttamaan konttien ympäristön kanssa.

Tarkistaaksesi Nginx-konttisi tuottamat lokit, voit käyttää komentoa logs:

docker compose logs

Näet samankaltaisen tuloksen kuin tämä:

Attaching to compose-demo_web_1
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

Jos haluat keskeyttää ympäristön suorituksen muuttamatta konttiesi nykyistä tilaa, voit käyttää:

docker compose pause

Pausing compose-demo_web_1 ... done

Jatkaaksesi suoritusta tauon jälkeen:

docker compose unpause

Unpausing compose-demo_web_1 ... done

stop-komento lopettaa kontin suorituksen, mutta se ei tuhoa mitään konteihisi liittyvää tietoa:

docker compose stop

Stopping compose-demo_web_1 ... done

Jos haluat poistaa tämän konttien ympäristöön liittyvät kontit, verkot ja tilat, käytä down-komentoa:

docker compose down

Removing compose-demo_web_1 ... done
Removing network compose-demo_default

Huomaa, että tämä ei poista sitä peruskuvaa, jota Docker Compose käyttää ympäristösi käynnistämiseen (tapauksessasi nginx:alpine). Näin ollen, aina kun käynnistät ympäristösi uudelleen komennolla docker compose up, prosessi on paljon nopeampi, koska kuva on jo järjestelmässäsi.

Jos haluat myös poistaa peruskuvan järjestelmästäsi, voit käyttää:

docker image rm nginx:alpine

Untagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

Vaihe 5 — Monipalvelusovelluksen rakentaminen

Docker Composen todellinen voima on useiden yhdessä toimivien palveluiden hallinnassa. Nginx-esimerkki oli yksittäinen palvelu. Luodaanpa käytännöllisempi monipalvelusovellus: WordPress-verkkosivusto, joka on yhdistetty MySQL-tietokantaan.

Tämä asennus sisältää kaksi palvelua: wordpress (suorittaa sovellusta) ja db (suorittaa tietokantaa). Käytämme myös Docker-volyymeja varmistaaksemme, että tietokantadata säilyy, vaikka kontti poistettaisiin.

Luodaan uusi hakemisto tälle sovellukselle:

mkdir -p ~/compose-demo/wordpressapp

cd ~/compose-demo/wordpressapp

Tässä esimerkissä emme tarvitse mitään paikallisia tiedostoja, sillä kuvat sisältävät kaiken tarvittavan ohjelmiston.

Luo uusi docker-compose.yml -tiedosto:

nano docker-compose.yml

Liitä seuraava määritys. Tämä tiedosto on monimutkaisempi, joten tarkastelemme jokaista osaa erikseen.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

volumes:
  db_data:

Tallenna ja sulje tiedosto. Muista korvata <^...^>-paikkamerkit vahvoilla, turvallisilla salasanoilla.

Käydään läpi tämän tiedoston uudet ohjeet:

• palvelut: Tämä lohko määrittelee edelleen konttimme. Meillä on nyt kaksi: db ja wordpress.
• image: Käytämme tietokannassa mysql:8.0 ja sovellukselle wordpress:latest -kuvaa.
• container_name: Tämä asettaa säiliölle tietyn, ihmisen luettavissa olevan nimen, johon on helpompi viitata kuin automaattisesti luotuihin nimiin.
• environment: Tämä on luettelo säilöön siirrettävistä ympäristömuuttujista. mysql-kuva käyttää näitä asettaakseen root-salasanan sekä luodakseen alkuperäisen tietokannan ja käyttäjän. wordpress-kuva käyttää niitä tietääkseen, miten se yhdistyy omaan tietokantaansa.

• volumes (palvelutaso):

  • `db`-palvelulle `db_data:/var/lib/mysql` yhdistää Dockerin hallitseman nimettyä `db_data` -volyymia MySQL:n tietohakemistoa varten säiliön sisällä. Tämä pitää tietosi turvassa.
  • WordPress-palvelulle wordpress, ./wp_content:/var/www/html/wp-content yhdistää paikallisen kansion (wp_content) WordPressin sisältöön. Tämä mahdollistaa teemojen ja lisäosien suoran muokkaamisen isäntäkoneeltasi.
• depends_on: Tämä kertoo Composelle, että db-palvelu täytyy käynnistää ennen kuin wordpress-palvelu käynnistyy. Tämä on tärkeää, sillä WordPress epäonnistuu, jos se ei löydä tietokantaansa käynnistyessä.
• volumes (ylätaso): Tämä lohko määrittelee nimetyt volyymit. db_data: luo Dockerin hallinnoiman volyymin, mikä on suositeltava tapa käsitellä pysyvää dataa.

Nyt käynnistä tämä monipalvelusovellus:

docker compose up -d

Compose lataa sekä mysql- että wordpress-kuvat ja luo sitten kontit, aloittaen ensin db-palvelusta.

Creating network "compose-demo_default" with the default driver
Creating volume "compose-demo_db_data" with default driver
Pulling db (mysql:8.0)...
...
Pulling wordpress (wordpress:latest)...
...
Creating mysql_db        ... done
Creating wordpress_app ... done

Voit nyt käyttää uutta WordPress-sivustoasi siirtymällä selaimessasi osoitteeseen localhost:8001 tai <^your_server_domain_or_IP<^>:8001. Näet WordPressin asennusnäytön. Tarkemman esimerkin löydät artikkelistamme Kuinka asentaa WordPress Docker Composen avulla.

Vaihe 6 — Docker Composen käyttäminen tekoäly- ja koneoppimiskehityksessä

Web-sovellusten lisäksi Docker Compose on erittäin hyödyllinen työkalu toistettavien data-analyysi- ja koneoppimisympäristöjen (AI/ML) luomiseen. AI/ML-projektit tunnetaan monimutkaisista riippuvuuksistaan, kuten tietyistä Python-versioista, TensorFlow- tai PyTorch-kirjastoista sekä järjestelmätason ajureista, kuten NVIDIA CUDA Toolkitistä. Docker Compose tallentaa koko tämän ympäristön konfiguraatiotiedostoihin, ratkaisten ongelman »se toimii koneellani», mikä on ratkaisevan tärkeää toistettavalle tutkimukselle.

Tässä esimerkissä luot monipalveluisen AI/ML-ympäristön, joka koostuu seuraavista:

• JupyterLab: Säilö interaktiiviseen kehitykseen, rakennettu mukautetusta Dockerfile-tiedostosta.
• PostgreSQL: Tietokantakontti kokeen tulosten ja metatietojen tallentamiseen.
• GPU-käyttö: JupyterLab-säilö tullaan konfiguroimaan käyttämään isäntäkoneen NVIDIA-GPU:ta, mikä on yleinen vaatimus mallien kouluttamisessa.

Tiedostorakenne

Ensiksi luo hakemisto projektille. Sen sisälle luot docker-compose.yml-tiedoston, jupyter-hakemiston, Jupyterille tarkoitetun Dockerfile-tiedoston ja requirements.txt-tiedoston. Rakenne pitäisi näyttää suunnilleen tältä:

ai-project/
├── docker-compose.yml
└── jupyter/
    ├── Dockerfile
    └── requirements.txt

Komponenttitiedostojen luominen

1. requirements.txt-tiedosto

Tämä tiedosto luettelee Python-paketit data-analytiikkaympäristöllesi.

nano jupyter/requirements.txt

Lisää tarvittavat paketit. Tässä esimerkissä lisäämme kirjastot datan käsittelyä, tietokantayhteyttä ja syväoppimisprosessia varten.

pandas
scikit-learn
tensorflow
jupyterlab
psycopg2-binary

Tallenna ja sulje tiedosto.

2. Dockerfile

Tämä tiedosto määrittelee mukautetun JupyterLab-palvelusi. Se käyttää virallista Jupyter-kuvaa pohjanaan ja asentaa paketit tiedostosta requirements.txt.

nano jupyter/Dockerfile

Liitä seuraava sisältö:

# Start from a base image that includes Jupyter and scientific libraries
FROM jupyter/scipy-notebook:latest

# Copy our local requirements file into the container
COPY requirements.txt /tmp/requirements.txt

# Install the Python packages
RUN pip install --no-cache-dir -r /tmp/requirements.txt

Tämä tiedosto ohjeistaa Dockeria käyttämään jupyter/scipy-notebook lähtöpisteenä, kopioimaan requirements.txt-tiedostosi konttiin ja käyttämään sitten pip-komentoa pakettien asentamiseen.

Ympäristön määrittäminen tiedostolla docker-compose.yml

Luo nyt pääasiallinen docker-compose.yml-tiedosto. Tämä tiedosto hallinnoi sekä db-palvelua että omaa jupyter-palveluasi.

nano docker-compose.yml

Liitä seuraava määritys korvaten <^...^>-paikkamerkit omilla suojatuilla tunnistetiedoillasi.

services:
  db:
    image: postgres:15-alpine
    container_name: ai_postgres_db
    environment:
      POSTGRES_USER: <^your_db_user^>
      POSTGRES_PASSWORD: <^your_db_pass^>
      POSTGRES_DB: experiments
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U <^your_db_user^> -d experiments"]
      interval: 10s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - ai_net

  jupyter:
    build: ./jupyter
    container_name: ai_jupyter_lab
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
    environment:
      - POSTGRES_HOST=db
      - POSTGRES_USER=<^your_db_user^>
      - POSTGRES_PASSWORD=<^your_db_pass^>
      - POSTGRES_DB=experiments
    restart: unless-stopped
    networks:
      - ai_net
    depends_on:
      db:
        condition: service_healthy
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  postgres_data:
    name: ai_project_data

networks:
  ai_net:
    driver: bridge

Tämä konfigurointitiedosto esittelee useita tärkeitä käsitteitä:

• build: ./jupyter: Tämä kertoo Docker Composelle rakentamaan mukautetun kuvan jupyter-palvelulle. Se etsii Dockerfile-tiedostoa määritetystä ./jupyter-hakemistosta.
• volumes: - ./notebooks:/home/jovyan/work: Tämä liittää paikallisen hakemiston nimeltä notebooks säiliöön. Tämä varmistaa, että kaikki luomasi Jupyter-muistikirjat tallentuvat suoraan isäntäkoneellesi, säilyen siellä jopa säiliön poiston jälkeen.
• healthcheck: Kuten vianmääritysluvussa on nähty, tämä tarkistus varmistaa, että db-palvelu ei vain käynnissä, vaan valmis vastaanottamaan yhteyksiä ennen muiden palveluiden käynnistymistä.
• depends_on: ... condition: service_healthy: Tämä kertoo jupyter-palvelulle, että sen tulee odottaa, kunnes db-terveystarkistus onnistuu, ennen kuin se käynnistyy.

• deploy.resources.reservations.devices: Tämä on lohko, joka pyytää GPU-käyttöoikeutta.

  • driver: nvidia: Määrittää käytettävän isäntäkoneen ajurin.
  • count: 1: Pyytää yhtä GPU:ta.
  • capabilities: [gpu]: Varmistaa, että kontilla on tarvittavat kyvyt GPU:n käyttämiseen.

AI/ML-ympäristön käyttö

Kun tiedostosi ovat paikallaan, voit rakentaa ja käynnistää palvelut.

1. Siirry ai-project -hakemistoosi ja suorita docker compose up -komento. Ensimmäisellä kerralla sinun on lisättävä --build-lipuke, jotta Compose tietää rakentaa mukautetun jupyter-kuvasi.

   docker compose up -d --build

2. Compose rakentaa ensin jupyter-kuvan (mikä voi kestää muutaman minuutin, kun TensorFlow ladataan), sitten se vetää postgres-kuvan ja lopuksi käynnistää molemmat kontit.

   [+] Building 5.8s (9/9) FINISHED
    => [internal] load build definition from Dockerfile
   ...
   [+] Running 3/3
    ✔ Network ai-project_ai_net        Created
    ✔ Container ai_postgres_db         Started
    ✔ Container ai_jupyter_lab         Started

3. Voit nyt käyttää JupyterLab-käyttöliittymää siirtymällä selaimessasi osoitteeseen http://localhost:8888 (tai <^your_server_ip^>:8888). Sinulta pyydetään tunnistetta (token), jonka saat säilön (container) lokitiedoista:

   docker compose logs jupyter

   Etsi rivi, joka on samanlainen kuin http://127.0.0.1:8888/lab?token=a1b2c3d4e5f6...

4. Jupyter-muistikirjassa voit nyt yhdistää tietokantaasi käyttämällä isäntänimeä db ja antamiasi kirjautumistietoja. Ympäristösi pääsee myös käyttämään isännän GPU:ta mallin kouluttamiseen.

Palveluiden skaalaaminen ja mukautettujen verkkojen käyttö

Docker Compose sisältää ominaisuuksia palveluiden skaalaamiseen ja niiden käyttämien verkkojen hallintaan.

Palvelun skaalaus replikoiden avulla

Kuvittele, että vaiheessa 2 käyttämäsi Nginx-verkkopalvelin saa liikaa liikennettä. Voit skaalata web-palvelua ajamaan useita kontti-instansseja. Docker Compose voi hallita tätä automaattisesti.

Palvelua voidaan laajentaa kahdella pääasiallisella tavalla.

1. Käyttämällä replicas-avainta (Suositeltu versiossa v2)

Voit määrittää halutun määrän instansseja suoraan docker-compose.yml-tiedostossasi käyttämällä deploy- ja replicas-avaimia. Tämä ominaisuus oli alun perin osa Docker Swarmia, mutta on nyt saatavilla myös tavallisissa Compose-järjestelyissä.

Muokkaa Nginx docker-compose.yml -tiedostoasi Vaiheessa 2:

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3

Kun suoritat docker compose up -d, Compose luo kolme web-konttia. Sinulla on kuitenkin ongelma: kaikki kolme yrittävät sitoutua isännän porttiin 8000. Tämä aiheuttaa “portti on jo varattu” -virheen toiselle ja kolmannelle kontille. Ratkaistaksesi tämän tuotantoympäristössä, sinun tulisi poistaa ports-määrittely web-palvelusta. Tällä tavalla web-kontit ovat saavutettavissa vain Docker-verkon sisällä. Erillinen kuormantasauspalvelu olisi ainoa, jolla olisi julkinen portti. Se jakaisi sitten liikenteen kolmelle web-replikalle.

Esimerkkikonfiguraatio voisi näyttää tältä (tämä on edistynyt esimerkki):

services:
  web:
    image: nginx:alpine
    # No 'ports' mapping here.
    # The service is only accessible inside the 'web-net' network.
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3
    networks:
      - web-net

  load_balancer:
    image: nginx:latest
    ports:
      - "80:80" # The load_balancer is the only service with a public port.
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf # A config file that load balances to 'web'.
    networks:
      - web-net
    depends_on:
      - web

networks:
  web-net:

Tässä asetuksessa load_balancer kuuntelee porttia 80 ja ohjaa pyynnöt sisäisesti kohteille web_1, web_2 ja web_3.

Tämä replicas-avain on hyödyllisin, kun sitä käytetään käänteisen välityspalvelimen (kuten Traefik tai toinen Nginx-instanssi) kanssa, joka voi tasapainottaa pyyntöjä replicas-kopioiden välillä Docker-verkossa ilman, että jokaisen kopion tarvitsee avoimesti käyttää porttia isäntäkoneessa.

2. --scale-lipun käyttäminen

Yleinen tapa skaalaamiseen on --scale-lippu, joka on siirtymää Compose v1:stä. Tätä lippua käytetään suoritusajossa, ja se ohittaa kaikki replicas-avaimen asetukset.

Kuitenkin sinun on oltava varovainen porttien määrittelyssä. Jos palvelusi määrittelee kiinteän isäntäportin kartoituksen (esim. "8000:80"), komennon docker compose up --scale suorittaminen aiheuttaa virheen toiselle ja kolmannelle kontille, koska kaikki yrittävät sitoa samaan isäntäporttiin.

Jos käytät --scale palveluille, jotka avaavat portteja, et saa käyttää kiinteää isäntaporttimääritystä.

• Vaihtoehto 1: Määritä satunnaiset isäntäportit (hyvä kehitykseen)

  Voit muokata tiedostoa docker-compose.yml määrittääksesi vain kontin portin. Tämä kertoo Dockerille, että se yhdistää jokaisen kontin portin 80 isäntäkoneesi satunnaiseen vapaaseen porttiin.

  services:
    web:
      image: nginx:alpine
      ports:
        - "80" # No fixed host port
      volumes:
        - ./app:/usr/share/nginx/html

  Nyt, kun suoritat scale-komennon:

  docker compose up -d --scale web=3

  Suorita docker compose ps nähdäksesi tuloksen. Jokainen kontti ajetaan eri, satunnaisesti määritetyllä isäntäportilla:

        Name                     Command               State          Ports        
  ----------------------------------------------------------------------------------
  compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49154->80/tcp
  compose-demo-web_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49155->80/tcp
  compose-demo-web_3   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49156->80/tcp

docker-compose.yml - Oikea käytettäväksi --scale

• Vaihtoehto 2: Käytä käänteistä välityspalvelinta (hyvä tuotantokäyttöön)

  Toinen ratkaisu, kuten replicas-osiossa mainittiin, on poistaa ports-direktiivi kokonaan web-palvelusta. Tämän jälkeen käyttäisit erillistä kuormantasauskonttia (jolla on ainoa julkinen portti) hallitsemaan ja jakamaan liikennettä skaalattuihin replikoihin Docker-verkon sisällä.

  Kolmen säiliön pysäyttämiseksi ja poistamiseksi komento pysyy samana:

  docker compose down

Mukautettu verkkokonfiguraatio

Oletusarvoisesti Docker Compose luo yhden bridge-verkon sovellustasi varten. Jokainen tiedoston palvelu liitetään siihen, mikä on syy siihen, että wordpress-kontti pystyi löytämään db-kontin pelkästään käyttämällä sen palvelun nimeä (db).

Voit kuitenkin määrittää omia mukautettuja verkkojasi paremman eristyksen ja hallinnan saavuttamiseksi.

Muokataan WordPress-esimerkkiä käyttämään mukautettua bridge-verkkoa.

services:
  db:
    image: mysql:8.0
    ...
    networks:
      - app_net

  wordpress:
    image: wordpress:latest
    ...
    ports:
      - "8001:80"
    depends_on:
      - db
    networks:
      - app_net

volumes:
  db_data:

networks:
  app_net:
    driver: bridge

Tässä on, mitä lisäsimme:

• verkot (ylätaso): Tämä määrittelee uuden verkon nimeltä app_net ja määrää sen käyttämään oletusarvoista bridge-ajuria.
• verkot (palvelutasolla): Sekä db- että wordpress-kohteiden alla tämä avain liittää ne app_net-verkkoomme.

Jos sinulla olisi kolmas palvelu (kuten analytiikkatyökalu), jota et liittäisi app_net-verkkoon, se olisi täysin eristetty eikä pystyisi kommunikoimaan db- tai wordpress-konttien kanssa.

Monipalvelinklusterointia varten käyttäen Docker Swarmia, sinun tulisi vaihtaa driver asetukseksi overlay bridge-asetuksen sijaan. Bridge-ajuri on tarkoitettu säilöjen väliseen kommunikointiin yhdellä isännällä, mikä on standardi useimmille Docker Composen käyttötapauksille.

Modulaaristen kokoonpanotiedostojen käyttäminen

Kun sovelluksesi kasvavat, docker-compose.yml -tiedostosi voi kasvaa suureksi ja vaikeaksi hallita. Docker Compose tukee include-direktiiviä, jonka avulla voit jakaa määrityksesi useisiin tiedostoihin.

Kuvittele, että haluat erottaa WordPress- ja tietokantamäärityksesi, ja ehkä käyttää yhteistä docker-compose.override.yml -tiedostoa kehitystä varten erityisiin asetuksiin (kuten portin sitominen tietokantaan).

Hakemistorakenteesi saattaa näyttää tältä:

compose-demo/
├── docker-compose.yml
├── docker-compose.db.yml
├── docker-compose.web.yml

Tämä tiedosto ainoastaan määrittelee db-palvelun.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

volumes:
  db_data:

Tämä tiedosto ainoastaan määrittelee wordpress-palvelun.

services:
  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

Nyt pääasiallinen docker-compose.yml-tiedostosi tulee erittäin yksinkertaiseksi. Se käyttää vain include-komentoa muiden tiedostojen tuomiseen.

include:
  - docker-compose.db.yml
  - docker-compose.web.yml

Kun suoritat docker compose up -d, Compose lukee kaikki kolme tiedostoa, yhdistää määritykset ja käynnistää db ja wordpress -palvelut aivan kuin ne olisi määritelty yhdessä tiedostossa. Tämä lähestymistapa tekee määrityksestäsi paljon modulaarisemman ja uudelleenkäytettävämmän.

Siirtyminen docker-compose (v1) -versiosta docker compose (v2) -versioon

Asennettu docker compose -komento Vaiheessa 1 on "Compose v2." Se on Go-pohjainen laajennus, joka on suoraan integroitu Dockerin komentorivityökaluun.

Alkuperäinen versio, „Compose v1”, oli erillinen Python-työkalu, jota kutsuttiin docker-compose-komennolla (väliviiva). Heinäkuusta 2023 alkaen Compose v1:ää ei enää tueta ja se on poistettu käytöstä.

Keskeiset muutokset ja taaksepäin yhteensopivuus

• Käsky: Näkyvin muutos on käsky. Viiva (docker-compose) on nyt välilyönti (docker compose).
• Asennus: Versio v1 asennettiin pip-komennolla. Versio v2 sisältyy Docker Desktoppin mukana tai se voidaan asentaa CLI-laajennuksena, kuten teit vaiheessa 1.
• YAML-tiedostot: docker-compose.yml -tiedostosi ovat lähes 100 % taaksepäin yhteensopivia. Compose v2 tukee täysin tiedostoversioita 3.x. Sinun ei tarvitse muuttaa YAML-tiedostojasi migraatiota varten, ainoastaan komentojasi.
• --project-name -valitsin: -p -valitsin toimii yhä, mutta koko valitsimen nimi on nyt --project-name aiemman --project_name sijaan.

Komentojen siirtymäopas

Useimmat komennot ovat identtisiä, vain väliviiva on poistettu. Tässä on taulukko, joka vertaa yleisiä v1-komentoja niiden v2-vastineisiin.

docker-compose up -d

docker compose up -d

docker-compose down

docker compose down

docker-compose ps

docker compose ps

docker-compose logs

docker compose logs

docker-compose stop

docker compose stop

docker-compose build

docker compose build

docker-compose exec web bash

docker compose exec web bash

docker-compose run web bash

docker compose run web bash

docker-compose up --scale web=3

docker compose up --scale web=3

Kuten näet, useimmassa päivittäisessä käytössä ainoa muutos on docker-compose -> docker compose. Jos käytät skriptejä, voit päivittää ne yksinkertaisesti poistamalla yhdysmerkin.

Jos sinulla on edelleen vanha docker-compose v1 asennettuna, voit poistaa sen välttääksesi sekaannusta:

sudo pip3 uninstall docker-compose

Tai, jos se asennettiin apt-komennolla:

sudo apt remove docker-compose

Yleisimpien Docker Compose -ongelmien vianmääritys

Kun työskentelet Docker Composen kanssa, saatat kohdata ongelmia liittyen tiedostojen syntaksiin, käyttöoikeuksiin tai säilön ajonaikaisiin ristiriitoihin. Useimmat ongelmat voidaan diagnosoida ja ratkaista tutkimalla järjestelmällisesti kokoonpanoasi, käyttöoikeuksia ja säilön lokitiedostoja.

Katsotaan joitakin yleisimpiä virheitä ja niiden ratkaisuja.

Lupa evätty (Docker-soketti)

Tämä on yksi yleisimmistä virheistä uusille Docker-käyttäjille. Suoritat docker compose up ja näet virheilmoituksen Docker-daemonin socketista.

permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

• Ongelma: Ei-root-käyttäjälläsi ei ole lupaa kommunikoida Docker-daemonin kanssa, joka toimii root-käyttäjänä.

• Ratkaisu: Sinun täytyy lisätä käyttäjäsi docker-ryhmään, joka luotiin Dockerin asennuksen aikana.

  1. Lisää käyttäjäsi docker-ryhmään:

     sudo usermod -aG docker ${USER}

  2. Uuden ryhmän jäsenyyden voimaantulemiseksi sinun on kirjauduttava ulos ja kirjauduttava takaisin.

  3. Vaihtoehtoisesti voit aktivoida ryhmän muutokset nykyiselle terminaalisessiollesi kirjoittamalla:

     newgrp docker

  Tämän pitäisi ratkaista kaikki Docker-sockettiin liittyvät käyttöoikeusvirheet.

YAML-syntaksin ja sisennyksen virheet

Docker Compose epäonnistuu suorituksessa ja ilmoittaa, että docker-compose.yml-tiedostosi on virheellinen.

ERROR: The Compose file './docker-compose.yml' is invalid because:
services.web.ports contains an invalid type, it should be a list

Tai :

mapping values are not allowed in this context at line 5

• Ongelma: docker-compose.yml-tiedosto perustuu tiukkaan YAML-syntaksiin. Yleisin virhe on virheellinen sisennys. YAML käyttää rakenteen määrittelyyn välilyöntejä, ei sarkaimia.

• Ratkaisu: Tarkista huolellisesti docker-compose.yml-tiedostosi sisennykset.

  • Vakio on kaksi välilyöntiä kutakin sisennyksen tasoa kohti.
  • Varmista, että kaikki samalla tasolla olevat avaimet (kuten version, services, volumes) alkavat samasta sarakkeesta.
  • Varmista, että kaikki alikohdat (kuten image, ports, volumes palvelun alla) on sisennetty kaksi välilyöntiä enemmän kuin niiden yläpalvelu (esim. web).
  • Käytä koodieditoria, jossa on YAML-linteri korostamaan syntaksivirheet automaattisesti.

Porttikonfliktit

Yrität käynnistää ympäristösi, mutta komento epäonnistuu virheilmoituksella, että osoite on jo käytössä.

Error starting userland proxy: listen tcp 0.0.0.0:8000: bind: address already in use

• Ongelma: Toinen prosessi isäntäkonettasi kuuntelee jo porttia, jota yrität kartoittaa (tässä tapauksessa portti 8000). Tämä on usein toinen Docker-kontti tai paikallinen kehityspalvelin.

• Ratkaisu: Sinulla on kaksi vaihtoehtoa:

  1. Pysäytä toinen prosessi. Voit löytää porttia käyttävän prosessin tällä komennolla:

     sudo lsof -i :8000

     Jos kyseessä on toinen Docker-kontti, pysäytä se komennolla docker stop <container_id>.

  2. Muuta isäntäkoneen porttia docker-compose.yml-tiedostossasi. Tämä on usein yksinkertaisin ratkaisu. Vaihda ports-määritys "8000:80"-arvosta toiseen porttiin, kuten "8001:80".

     ...
     ports:
       - "8001:80" # Changed from 8000
     ...

  docker-compose.yml

Palvelu epäonnistuu virheellä Yhteys evätty (depends_on)

Monipalvelusovelluksessa (kuten WordPress- ja MySQL-esimerkissä) wordpress-säiliö käynnistyy, mutta sen lokeissa näkyy Connection refused tai MySQL server has gone away, kun se yrittää muodostaa yhteyden db-palveluun.

• Ongelma: Olet käyttänyt depends_on-direktiiviä, mutta tämä ohje vain odottaa, että db-kontti käynnistyy. Se ei odota, että MySQL -sovellus kontin sisällä on täysin alustettu ja valmis vastaanottamaan yhteyksiä.

• Ratkaisu: Sovellus (tässä tapauksessa WordPress) on määritettävä yrittämään yhteyden muodostamista uudelleen. Useimmissa nykyaikaisissa kuvissa tämä uudelleenyrityslogiikka on valmiiksi sisäänrakennettu. Kuviin, joissa sitä ei ole, on toteutettava terveystarkistus.

  Voit lisätä healthcheck-tarkistuksen db-palveluusi. Wordpress-palvelun depends_on voidaan sitten määrittää odottamaan, että tietokanta on "terve", ei vain "käynnistetty".

Esimerkkitarkastus MySQL:lle:

services:
  db:
    image: mysql:8.0
    ...
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p<^your_root_password_here<^>"]
      interval: 10s
      timeout: 5s
      retries: 5

  wordpress:
    image: wordpress:latest
    ...
    depends_on:
      db:
        condition: service_healthy # This now waits for the healthcheck
    ...

Virheitä volyymien ja sidottujen liitteiden kanssa

Saatat kohdata käyttöoikeusvirheitä konttisi lokitiedoissa tai huomata, että konttisi datakansio on tyhjä.

Tiedoston/kansion käyttöoikeudet

• Ongelma: Säiliö ajetaan tietyn käyttäjänä (esim. www-data käyttäjätunnuksella 33), mutta isäntäkansio, jonka liitit, omistaa sinun käyttäjäsi (esim. ubuntu käyttäjätunnuksella 1000). Säiliön käyttäjällä ei ole oikeuksia kirjoittaa isäntäkansioon.

• Ratkaisu: Vaihda isäntäkansion omistajuus vastaamaan kontin sisäistä käyttäjätunnusta. Voit selvittää kontin käyttäjätunnuksen suorittamalla docker compose exec <service_name> id. Esimerkiksi, jos tunnus on 33 (yleistä www-data-käyttäjälle):

  sudo chown -R 33:33 ./wp_content

Suhteellisten polkujen ongelmat

• Ongelma: docker-compose.yml-tiedostosi käyttää suhteellista polkua kuten ./app, mutta index.html-tiedostoa ei toimiteta.

• Ratkaisu: Docker Compose tulkitsee suhteelliset polut siitä hakemistosta, josta suoritat docker compose up -komennon. Suorita aina Compose-komennot samasta hakemistosta, joka sisältää docker-compose.yml -tiedostosi.

Verkottuminen ja palveluiden havaitseminen

Sovelluksesi konttilokit näyttävät Isäntää ei löytynyt tai Isäntää ei voitu ratkaista: db.

• Ongelma: wordpress-säilösi ei löydä db-säilöä verkosta.

• Ratkaisu: Oletuksena Docker Compose luo verkon ja liittää kaikki palvelut siihen. Palvelut voivat löytää toisensa käyttämällä palveluidensa nimiä.

  1. Tarkista palvelun nimet: Varmista, että sovelluksesi asetuksissa oleva isäntänimi (esim. WORDPRESS_DB_HOST -ympäristömuuttuja) on täsmälleen sama kuin palvelun nimi docker-compose.yml-tiedostossasi (esim. db).

  2. Tarkista verkko: Käytä docker compose ps löytääksesi projektisi nimen (esim. compose-demo). Tarkista sitten oletusverkko:

     docker network inspect compose-demo_default

     JSON-tuloste listaa kaikki tämän verkon liitetyt kontit. Jos jokin palveluistasi puuttuu, tarkista docker-compose.yml-tiedostosi mahdollisten mukautettujen networks-asetusten varalta, jotka saattavat eristää sen.

Komentojen yhteensopimattomuus (v1 vs. v2)

Kirjoitat docker-compose up (viivalla) ja näet “komentoa ei löydy” -virheen.

docker-compose: command not found

• Ongelma: Yrität käyttää Compose v1 -komentoa, joka on vanhentunut Python-työkalu. Tämä opas asentaa Compose v2:n, joka on liitännäinen suoraan Docker CLI:hin integroituna.
• Ratkaisu: Käytä oikeaa komentoa korvaamalla yhdysmerkki (-) välilyönnillä.

Käytä tämän oppaan seuraamisen aikana aina docker compose (välilyönti).

UKK

1. Mihin Docker Composea käytetään?

Docker Compose on työkalu monisäiliöisten Docker-sovellusten määrittelyyn ja ajamiseen.

Se käyttää yhtä YAML-tiedostoa (oletuksena docker-compose.yml) kaikkien sovelluksesi komponenttien, joita kutsutaan palveluiksi, määrittämiseen. Tämä tiedosto määrittelee myös verkot, jotka mahdollistavat palveluiden välisen viestinnän, sekä volyymit, joita käytetään pysyvän datan tallentamiseen.

Tällä yhdellä tiedostolla voit hallita koko sovelluspinosi yksinkertaisilla komennoilla:

• docker compose up käynnistää ja suorittaa koko sovelluksesi, mukaan lukien kaikki määritetyt kontit, verkot ja tilat.
• docker compose down pysäyttää ja poistaa kaikki sovelluksesi luomat kontit, verkot ja tallennustilat.

Se on erityisen hyödyllinen sovellusten hallinnassa, jotka tarvitsevat useita osia, kuten verkkosivusto, joka tarvitsee verkkopalvelimen (kuten Nginx), sovelluspalvelimen taustan (kuten WordPress) ja tietokannan (kuten MySQL).

2. Kuinka asennan Docker Composen Ubuntulle?

Suositeltu menetelmä on asentaa Docker Compose Dockerin komentorivityökalun (CLI) laajennuksena. Tämä tehdään asentamalla docker-compose-plugin-paketti Dockerin virallisesta apt-arkistosta.

1. Varmista ensin, että olet noudattanut Dockerin virallista dokumentaatiota asentaaksesi Dockerin apt-arkiston Ubuntu-järjestelmääsi.

2. Päivitä pakettien luettelo:

   sudo apt update

3. Asenna Docker Compose -laajennus:

   sudo apt install docker-compose-plugin

4. Varmista asennus tarkistamalla versio. Komennossa käytetään välilyöntiä, ei viivaa.

   docker compose version

3. Kuinka päivitän Docker Composen uusimpaan versioon?

Koska Docker Compose (v2) on asennettu järjestelmäpakettina käyttämällä apt-komentoa, voit päivittää sen tavallisen Ubuntun ohjelmistopäivitysprosessin kautta.

1. Päivitä paikallinen pakettihakemisto:

   sudo apt update

2. Suorita koko järjestelmän päivitys, johon sisältyy Compose-laajennus:

   sudo apt upgrade

   Vaihtoehtoisesti, jos haluat päivittää vain itse lisäosan, voit suorittaa:

   sudo apt install --only-upgrade docker-compose-plugin

4. Voiko Docker Composea käyttää tuotantoympäristöissä?

Kyllä, Docker Composea käytetään usein tuotannossa, erityisesti sovelluksissa, jotka toimivat yhdellä palvelimella.

Se tarjoaa suoraviivaisen tavan määritellä, ottaa käyttöön ja hallita sovelluksesi palveluiden, verkkojen ja tallennustilojen elinkaarta. Yhden palvelimen käyttöönotossa se on erittäin tehokas ja helposti hallittava ratkaisu.

Monimutkaisemmissa tilanteissa, jotka vaativat konttien koordinointia useiden isäntien välillä (klusteri), käytetään yleisemmin muita työkaluja. Näihin kuuluvat Docker Swarm (joka käyttää samanlaista Compose-tiedoston syntaksia) ja Kubernetes (joka on teollisuuden standardi suurten konttiorganisaatioiden hallinnassa).

5. Mikä on ero Dockerin ja Docker Composen välillä?

Tämä taulukko esittelee tärkeimmät erot Docker CLI:n ja Docker Compose CLI:n välillä.

Lyhyesti sanottuna, käytät docker-komentoa kommunikoidaksesi yksittäisen kontin kanssa. Käytät docker compose-komentoa hallitaksesi koko sovelluspinostasi (esim. web, sovellus, tietokanta) kerralla.

6. Kuinka suoritan useita kontteja Docker Composen avulla?

Aja useita kontteja määrittelemällä ne palveluina docker-compose.yml -tiedostossasi.

1. Luo tiedosto nimeltä docker-compose.yml.

2. Tässä tiedostossa käytä services:-avainsanaa määrittääksesi jokaisen säilön, jonka haluat käynnistää.

   Tässä on käytännön esimerkki, joka määrittelee ja suorittaa kaksi konttia: WordPress-sivuston ja MySQL-tietokannan.

   services:
     db:
       # This is the first service (container)
       image: mysql:8.0
       environment:
         MYSQL_ROOT_PASSWORD: <^your_password_here<^>
         MYSQL_DATABASE: wordpress
       volumes:
         - db_data:/var/lib/mysql
   
     wordpress:
       # This is the second service (container)
       image: wordpress:latest
       ports:
         - "8001:80"
       environment:
         WORDPRESS_DB_HOST: db
         WORDPRESS_DB_PASSWORD: <^your_password_here<^>
       depends_on:
         - db
   
   volumes:
     db_data:

docker-compose.yml

3. Tallenna tiedosto ja avaa komentorivi samassa kansiossa.

4. Suorita yksi komento käynnistääksesi molemmat kontit:

   docker compose up -d

Docker Compose lukee tiedoston, luo palveluille yhteisen verkon, lataa sekä mysql- että wordpress-kuvat ja käynnistää kontin jokaiselle palvelulle.

7. Miksi käyttää Docker Composea kehityksessä?

Docker Compose on yleinen työkalu kehitysympäristöissä, koska se ratkaisee useita yleisiä ongelmia.

• Yhtenäiset ympäristöt: Se varmistaa, että jokainen tiimin kehittäjä käyttää täsmälleen samoja palveluita (tietokanta, välimuisti, verkkopalvelin) täsmälleen samoilla versioilla ja asetuksilla. Tämä määritellään docker-compose.yml-tiedostossa, joka tallennetaan versionhallintaan. Tämä poistaa „toimii koneellani”-ongelman.

• Yksinkertaisuus: Se korvaa monimutkaiset asennusskriptit ja pitkät docker run -komennot. Kehittäjän tarvitsee vain suorittaa docker compose up käynnistääkseen koko sovelluspino ja docker compose down pysäyttääkseen sen.

• Palvelujen eristäminen: Kehittäjät voivat työskennellä useiden projektien parissa samalla koneella ilman riippuvuuksien konflikteja. Projekti A voi käyttää PostgreSQL 9.6:ta ja Projekti B PostgreSQL 14:ää, koska kukin tietokanta toimii eristetyssä kontissa, jota hallinnoi oma Compose-tiedostonsa.

• Helppo integraatiotestaus: Koska Compose käynnistää kaikki sovelluksen riippuvuudet yhdessä, se luo täydellisen paikallisen ympäristön suorittaa integraatiotestejä, jotka varmistavat, miten palvelut ovat vuorovaikutuksessa keskenään.

Johtopäätös

Tässä oppaassa asensit Docker Compose -ohjelman ja konfiguroit täydellisen monisäiliöisen sovelluksen. Aloitit perus docker-compose.yml -tiedostolla Nginx-verkkopalvelimelle ja etenit monimutkaisempaan, realistisempaan pinoon, joka sisälsi WordPress-sovelluksen ja MySQL-tietokannan. Olet oppinut hallitsemaan koko sovelluksen elinkaaren, palveluiden rakentamisesta ja ajamisesta niiden pysäyttämiseen ja poistamiseen.

Olet nyt perehtynyt keskeisiin käsitteisiin sovellusten tehokkaaseen hallintaan, mukaan lukien palveluiden skaalaus, mukautetut verkkoyhteydet ja konfiguraation jakaminen modulaarisiin tiedostoihin include-direktiivin avulla. Seuraamalla siirtymisopasta ja vianmääritysvaiheita voit myös ratkaista yleisiä ongelmia, kuten porttien ristiriitoja, “Lupa evätty”-virheitä ja YAML-syntaksivirheitä. Tässä käsitellyt taidot mahdollistavat johdonmukaisten, toistettavien kehitysympäristöjen rakentamisen ja yksittäisen palvelimen sovellusten luotettavan käyttöönoton.

Kaikkien saatavilla olevien docker compose -komentojen täydellisen viitteen löydät virallisesta dokumentaatiosta.

Lisätietoja Docker-aiheisista opetusohjelmista löydät seuraavista artikkeleista:

• Kuinka asentaa Docker Ubuntuun – Askel askeleelta -opas
• Kuinka asentaa WordPress Docker Composen avulla

Kiitos, että opiskelet Linux-Console.net-yhteisön kanssa.