Vše, co potřebujete vědět o používání Docker Compose

Pokud vás zajímá, jak vytvořit reprodukovatelné kontejnery Docker pomocí Docker Compose, jste na správném místě. V tomto podrobném tutoriálu Docker Compose se naučíte, jak vytvářet jednoduché kontejnery, mapovat porty pomocí Docker Compose až po složité scénáře s více kontejnery.

Jsi připraven? Pojďme se do toho pustit!

Předpoklady

Pokud chcete v tomto tutoriálu postupovat krok za krokem, ujistěte se, že máte následující:

1. Nová instalace Ubuntu Server LTS s povoleným SSH . Tato příručka bude používat Ubuntu Server LTS 20.04.1 jako hostitelský počítač Docker.
2. Počítač s kódem VS nainstalované (volitelné). Tato příručka bude používat Visual Studio Code 1.52.1 pro SSH pro hostitele Dockeru a spouštění příkazů.
3. Nainstalováno oficiální rozšíření SSH VS Code a připojen k hostiteli Docker. (volitelné)

Co je Docker Compose?

Jednotlivé příkazy mohou být v Dockeru dlouhé, opravdu dlouhé. Vezměte si níže uvedený příklad. Tento příklad vytvoří kontejner pro softwarovou aplikaci s názvem bookstack.

docker create \
   --name=bookstack \
   -e PUID # UID of user to take ownership of application/files \
   -e PGID # GID of user to take ownership of application/files \
   -e DB_USER # The database user \
   -e DB_PASS # The database password \
   -e DB_HOST # The database host \
   -e DB_DATABASE # The database to be used \
   -e APP_URL # The url your application will be accessed on (required for correct operation of reverse proxy) \
   -v /host/path/to/config:/config # Location of any uploaded data \
   -p 80:80/tcp # Web UI port \
   --restart unless-stopped \
   linuxserver/bookstack:version-v0.31.4

Se zvyšující se složitostí prostředí dockeru roste i množství příznaků a podmínek požadovaných pro nastavení pracovního kontejneru. Příkazový řádek Dockeru začíná být těžkopádný a obtížně řešitelný; zvláště poté, co do mixu začnou vstupovat nastavení s více kontejnery.

Docker Compose je způsob, jak vytvořit reprodukovatelné kontejnery Dockeru pomocí konfiguračního souboru namísto extrémně dlouhých příkazů Dockeru. Při použití strukturovaného konfiguračního souboru je snazší odhalit chyby a snáze definovat interakce kontejnerů.

Docker Compose se rychle stává neocenitelným při řešení závislostí kontejnerů nebo prostředí s více kontejnery.

Docker Compose je fantastický způsob, jak vstoupit do Infrastructure as Code bez složitosti distribuovaných systémů, jako je Kubernetes.

Docker Compose používá strukturu konfiguračního souboru nazvanou YAML . YAML je podobný JSON nebo HTML v tom, že YAML je strukturovaný, strojově čitelný jazyk. YAML se specificky zaměřuje na to, aby byl co nejčitelnější pro člověka a zároveň si zachoval tuto strukturovanou sílu.

YAML má nevýhodu, kdy jsou tabulátory a další mezery významné a musí být správně naformátovány. VS Code dělá hodně této těžké práce za vás a také proto uvidíte mnoho příkladů, které se dělají ve VS Code.

Instalace Docker Compose

Pojďme si teď začít špinit ruce. Za předpokladu, že jste připojeni k hostiteli Dockeru, je čas nainstalovat Docker Compose.

Docker Compose je samostatný balíček od runtime Dockeru. Instalací Docker Compose se však nainstaluje také runtime Docker, takže zabijete dvě mouchy jednou ranou!

Chcete-li nainstalovat Docker Compose a runtime Docker, spusťte následující dva příkazy.

# update the software list (known as a repository) and then install docker compose
# with any needed dependencies. the -y flag is used to skip confirmation
sudo apt update -y
sudo apt install docker-compose -y

Po instalaci byste nyní měli vytvořit strukturu složek pro ukládání kontejnerů.

Vytvoření struktury složek pro Docker Compose

Než budete moci vytvořit kontejner pomocí Docker Compose, měli byste nejprve vytvořit složku pro ukládání kontejnerů. Měli byste nejen vytvořit strukturu složek pro ukládání kontejnerů, ale zjistíte, že různé příkazy Dockeru jsou citlivé na umístění různých konfiguračních souborů; Docker Compose se neliší.

Nejdůležitější součástí Docker Compose je jeho konfigurační soubor s názvem docker-compose.yaml . Tento konfigurační soubor, jak je vysvětleno výše, určuje, jak má běhové prostředí Dockeru sestavit kontejner.

Když spustíte Docker Compose, příkaz vyhledá svůj konfigurační soubor ve stejné složce, ve které je příkaz spuštěn. Vzhledem k tomuto požadavku je vždy nejlepší při spuštění Docker Compose vytvořit samostatnou složku.

V každé složce může být pouze jeden konfigurační soubor Docker Compose.

Chcete-li předvést vytvoření kontejneru Docker pomocí Docker Compose, nejprve vytvořte strukturu složek pro uložení budoucího kontejneru a jeho konfiguračního souboru pomocí malého souborového serveru s názvem Caddy.

Caddy je souborový server podobný apache httpd nebo nginx , ale napsaný v jazyce Go. Caddy je speciálně navržen pro snadné použití (a automaticky vygeneruje nebo poskytne soubor index.html) bez konfigurace. Díky této kombinaci je caddy dobrou volbou pro začátečníky.

Za předpokladu, že jste přihlášeni k hostiteli Docker, vytvořte strukturu složek následovně:

1. Ve svém domovském adresáři vytvořte složku s názvem containers . Tato složka bude dobrým zástupným symbolem pro tento a další kontejnery.
2. Uvnitř kontejnerů vytvořte podsložku s názvem caddy . Tato složka bude obsahovat konfigurační soubor Docker Compose a samotný kontejner Caddy.
3. Nakonec ve složce kontejneru, caddy, vytvořte prázdný textový soubor s názvem docker-compose.yaml který se stane konfiguračním souborem Docker Compose.

Po vytvoření struktury složek a konfiguračního souboru Docker Compose můžete nyní začít vyplňovat tento konfigurační soubor pomocí konfigurace Docker Compose.

Vytvoření konfiguračního souboru Docker Compose

Ve své nejzákladnější podobě, docker-compose.yaml soubor pro kontejner caddy vypadá následovně. Ve svém oblíbeném textovém editoru Linux nebo pomocí kódu VS zkopírujte a vložte níže uvedený kód do dříve vytvořeného konfiguračního souboru Docker Compose.

version: "3.7"
services:
  caddy:
    container_name: "caddy"
    image: "caddy:latest"
    ports:
      - "80:80"

Pojďme si projít každou ze zobrazených možností:

• version určuje verzi souboru docker-compose. Každá nová definice Docker Compose zahrnuje zásadní změny ve specifikaci. Verze je proto důležitá, aby Docker Compose mohl říct, jaké funkce potřebuje použít. Verze 3.7 je nejnovější verze, kterou Ubuntu 20.04.1 LTS podporuje.

Úplnou specifikaci pro Docker Compose 3.x naleznete zde. Propojená dokumentace zmiňuje každou jednotlivou možnost, kterou můžete použít v rámci Docker Compose

• services obsahovat specifikace pro skutečné nádoby. V této sekci můžete definovat více kontejnerů.
• caddy je název prvního kontejneru (toto je čistě pro informaci).
• container_name definuje skutečný název daný kontejneru Dockerem a musí být jedinečný.
• image je název obrázku. V tomto případě caddy z Docker Hub je definováno. Název nebo číslo za značkou oddělené dvojtečkou je verze.

Mapování portů

Zejména tato poslední možnost vyžaduje zvláštní zmínku:

ports:
  - "80:80"

V Docker Compose, ports direktiva umožňuje nastavit jedno nebo více mapování z hostitele do kontejneru. Například výše máte namapovaný port 80 na hostiteli na port 80 na nádobě. Nemusíte však odpovídat číslu portu. Níže uvedený příklad mapuje port 8800 na hostiteli na port 80 v kontejneru.

ports:
  - "8800:80"

Můžete také definovat více portů, jak je uvedeno níže.

ports:
  - "80:80"
  - "443:443"

Pokud tak učiníte, zmapujete oba porty 80 a 443 k hostiteli (běžná konfigurace pro webové servery pro obsluhu HTTP i HTTPS).

Tvůrce obrazu Docker definuje dostupné porty v době vytvoření. Nezapomeňte zkontrolovat dokumentaci k obrazu, se kterým pracujete, na Docker Hub nebo na webu správce, zda neobsahuje mapovatelné porty. Nemá smysl mapovat port, pokud se port nepoužívá!

S ohledem na to se podívejme na skutečné spuštění kontejneru.

Spuštění kontejneru

Nyní byste měli mít soubor docker-compose.yaml soubor uvnitř vašeho ~\containers\caddy složka. Nyní je čas vytvořit a spustit kontejner Caddy.

Na svém terminálu spusťte následující příkaz, který vyvolá kontejnery Docker definované v docker-compose.yaml soubor.

# This command must be run in the same folder as the file. The -d flag runs
# the command *detached*, which will bring up the container in the background
sudo docker-compose up -d

Můžete si všimnout, že jste při spouštění sudo docker-compose up -d nemuseli zadávat umístění souboru docker-compose.yaml . Docker Compose očekává, že budete spouštět všechny příkazy ve složce, která obsahuje soubor docker-compose.yaml, protože mnoho příkazů se vztahuje k této složce.

Nyní ověřte, že je kontejner v provozu, přejděte na http:// . Tato příručka používá http://homelab-docker pro referenci.

Toto zpracování, které probíhá v kódu VS, zatímco je SSH přeneseno do hostitele Docker, můžete vidět v animaci níže:

Úspěch! Nyní jste úspěšně použili Docker Compose ke spuštění kontejneru z konfiguračního souboru. Po tomto prvním důležitém kroku se podíváme, jak spravujete stav svého kontejneru.

Příkazy pro správu oddělených kontejnerů

V předchozí části jste spustili kontejner nosiče pomocí -d vlajka. Tím spustil kontejner v odděleném Stát. Když je kontejner v odpojeném stavu, bude kontejner nadále běžet na pozadí. To však představuje problém:jak tento kontejner spravovat, když již nemáte přímou kontrolu?

K vyřešení tohoto problému má Docker Compose řadu příkazů, které budou spravovat kontejnery spouštěné pomocí docker-compose.yaml soubor:

• docker-compose restart se používá k restartování kontejneru, který je aktuálně spuštěn. To se liší od skutečného opětovného spuštění docker-compose up -d . Příkaz restart jednoduše restartuje existující kontejner, znovu spusťte docker-compose up -d a znovu vytvořte kontejner od začátku (pokud byl konfigurační soubor změněn).
• docker-compose stop zastaví běžící kontejner bez zničení kontejneru. Podobně docker-compose start znovu spustí kontejner.
• docker-compose down zastaví běžící kontejnery a také je zničí . Zde vstupuje do hry vazba svazků (více informací níže).
• docker-compose pull stáhne aktuální verzi obrázku dockeru (nebo obrázků) z úložiště. Pokud používáte latest tag, můžete následovat pomocí docker-compose down && sudo docker-compose up -d k nahrazení kontejneru nejnovější verzí. Pomocí docker-compose pull je pohodlný způsob, jak rychle aktualizovat kontejnery s minimálními prostoji.
• docker-compose logs zobrazí protokoly běžícího (nebo zastaveného) kontejneru. Jednotlivé kontejnery (pokud je v souboru pro vytváření zpráv definováno více kontejnerů) můžete také adresovat pomocí docker-compose logs <container name> .

Úplný seznam příkazů docker-compose lze zobrazit spuštěním docker-compose bez dalších argumentů nebo odkazovaných zde v dokumentaci.

Nyní, když máte spuštěný kontejner, pojďme se podívat na používání obsahu uloženého lokálně na vašem počítači.

Vytvoření Bind Mounts v Docker Compose

Vazba držáků jak Docker mapuje důležitá uživatelská data do místního úložiště na vašem serveru. Chcete-li začít, vygenerujte obsah pro kontejner, který bude hostovat:

1. Na hostiteli Docker, Uvnitř ~/containers/caddy vytvořte novou složku s názvem soubory .

2. Vytvořte nový soubor s názvem index.html uvnitř ~/containers/caddy složku, která vypadá níže. Toto bude hlavní stránka, kterou bude webový server Caddy zobrazovat.

<body><h2>hello world!</h2></body>

3. Upravte svůj konfigurační soubor Docker Compose tak, aby vypadal níže. Níže uvedený ukázkový soubor přidává volumes sekce a nasměrování připojení k souborům právě vytvořená složka, aby byla dostupná pro kontejner.

version: "3.7" services: caddy: container_name: "caddy" image: "caddy:latest" ports: - "80:80" volumes: #the ./ refers a folder relative to the docker-compose file - "./files:/usr/share/caddy"

4. Spusťte docker-compose up -d znovu. Docker Compose nyní rozpozná, že soubor byl změněn, a znovu vytvoří váš kontejner.

5. Přejděte v prohlížeči na stránku kontejneru a nyní byste měli vidět, že slouží „Hello World!“ stránku.

V níže uvedené animaci můžete vidět následující:

Nyní hostujete obsah uložený lokálně na vašem počítači! Co když je však váš obsah na externím zdroji, jako je sdílená síť?

Použití Docker Compose s Docker Volumes

Jakmile vytvoříte jednoduchý kontejner pomocí Docker Compose, pravděpodobně budete tento kontejner potřebovat pro přístup k souborům někde jinde, možná ve sdílené síťové složce. Pokud ano, můžete nakonfigurovat kontejner pro použití svazků Docker přímo v konfiguračním souboru Docker Compose.

Pro demonstrační účely bude tato příručka vytvářet server Network File Share (NFS) na hostiteli Docker. Poskytování místního obsahu jako připojení NFS nemá žádný praktický účel mimo ukázku. Pokud byste měli připojit svazek NFS, bude to obecně z externího zdroje, jako je NAS nebo vzdálený server.

Nastavit sdílení NFS

Pokud ještě nemáte nastavenou sdílenou složku NFS, vytvořte si ji nyní na hostiteli Docker pro tento výukový program. Postup:

1. Nainstalujte Server NFS balík spuštěním apt install nfs-kernel-server -y .

2. Přidejte kontejner jako export NFS (podobně jako sdílení Windows CIFS) spuštěním následujícího.

# Add a line to the /etc/exports config file to create a NFS share for # /home/homelab/containers. This share is only exposed to localhost (to # prevent other computers from having access) echo '/home/homelab/containers localhost(rw,sync,no_root_squash,no_subtree_check)' | sudo tee -a /etc/exports # Restart the NFS server with the new config sudo systemctl restart nfs-kernel-server

3. Nyní ověřte, že hostitel odhaluje sdílenou složku NFS spuštěním příkazu showmount -e localhost . Tento příkaz zobrazí všechny aktuálně vystavené sdílené složky NFS a kdo má přístup.

Na níže uvedeném snímku obrazovky můžete vidět /home/homelab/containers je vystaven, ale pouze počítači localhost (což je stejný server, na kterém běží hostitel Docker).

Pokud vidíte složku /home//containers ve výstupu je nastaveno sdílení NFS.

Definování pojmenovaného svazku Docker

Jakmile vytvoříte sdílenou složku NFS, musíte nyní společnosti Docker sdělit, jak k této sdílené složce přistupovat. Pomocí Docker Compose to můžete provést definováním pojmenovaného svazku v konfiguračním souboru Docker Compose.

Pojmenovaný svazek je pro Docker způsob, jak abstraktní sdílení souborů na síti. Sdílení souborů v síti má v dnešní době nejrůznější tvary a velikosti:sdílení CIFS (windows), sdílení NFS (Linux), AWS S3 Buckets a další. Vytvořením pojmenovaného svazku Docker udělá tu obtížnou část při zjišťování, jak komunikovat se sdíleným síťovým úložištěm, a umožní kontejneru, aby se ke sdílené složce choval, jako by šlo o místní úložiště.

Chcete-li vytvořit pojmenovaný svazek:

1. Otevřete konfigurační soubor Docker Compose (docker-compose.yaml ). Pokud sledujete, soubor by měl být umístěn v ~/containers/caddy složka.

2. Do konfiguračního souboru Docker Compose přidejte volumes sekce za services sekce. Váš konfigurační soubor by měl vypadat níže. volumes sekce vytvoří pojmenovaný svazek s názvem MyWebsite . V rámci tohoto pojmenovaného svazku jsou specifikovány potřebné parametry (jako je IP, nastavení NFS a cesta). volumes parametr v rámci services sekce je také upravena tak, aby ukazovala na název svazku, nikoli na místní složku.

version: "3.7"
 services:
   caddy:
     container_name: "caddy"
     image: "caddy:latest"
     ports:
       - "80:80"
     volumes:
       - "MyWebsite:/usr/share/caddy"
 volumes:
   MyWebsite:
     driver_opts:
       type: "nfs"
       o: "addr=localhost,nolock,soft,rw"
       device: ":/home/homelab/containers/caddy/files"

3. Jakmile definujete pojmenovaný svazek ukazující na sdílenou složku NFS v konfiguračním souboru Docker Compose, spusťte docker-compose up -d vytvořit a spustit kontejner. Pokud vše půjde dobře, kontejner a web by se měly vrátit zpět.

4. Znovu přejděte na stránku kontejneru. Soubor index.html obsah by měl vypadat stejně, jako kdyby byl soubor připojen lokálně. Tento soubor se však připojuje prostřednictvím serveru NFS nastaveného v síti.

Vzhledem k tomu, že nyní můžete v Docker Compose připojit externí svazky Dockeru, můžete nyní do svých kontejnerů přenést všechny druhy síťového úložiště. Docker Compose však umí více než jen definovat jednotlivé kontejnery nebo svazky. Pojďme se ponořit do složitějších scénářů s více kontejnery.

Tento výukový program již nebude používat kontejner nosiče, takže kontejner můžete odstranit pomocí docker-compose down .

Definování více kontejnerů v Docker Compose

Většina kontejnerů Docker nefunguje ve vakuu. Kontejnery Docker obvykle mají závislosti na službách, jako jsou databáze nebo samostatné webové služby, které mluví přes API.

Pomocí Docker Compose můžete seskupit kontejnery definované v rámci jednoho souboru. Definováním více kontejnerů v jednom souboru mohou kontejnery komunikovat mezi závislými službami a zjednodušit organizaci složitých rozložení kontejnerů.

Abychom takový scénář demonstrovali, nastavíme populární wiki aplikaci s názvem BookStack .

BookStack je oblíbený wiki software známý pro své snadné použití a hierarchické uspořádání (na rozdíl od plochého rozložení, jako je mediawiki).

BookStack, stejně jako mnoho webových aplikací, vyžaduje ke správnému fungování samostatnou databázi a také informace potřebné pro komunikaci s databází. Nastavení takové situace je místo, kde Docker Compose exceluje.

Vytvoření konfiguračního souboru Docker Compose

BookStack však nemá interně udržovaný obraz Docker, linuxserver.io udržuje renomovaný image Docker Hub jménem BookStack. Zatímco dokumentace na webu docker hub obsahuje doporučený konfigurační soubor Docker Compose, tento tutoriál vytvoří nový konfigurační soubor a zároveň vysvětlí koncepty.

Na hostiteli Docker:

1. Nejprve vytvořte složku pro BookStack. Pokud jste postupovali podle výukových programů v předchozí části, měli byste mít ~/containers složka. Vytvořte složku s názvem bookstack tam.

2. Poté vytvořte prázdný konfigurační soubor Docker Compose s názvem docker-compose.yaml uvnitř knihovny složka.

3. Nyní otevřete konfigurační soubor Docker Compose a definujte dva kontejnery:bookstack kontejner a bookstack_db (mariadb) kontejner.

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"

Zatím toto docker-compose.yaml soubor většinou používá již zavedené pojmy:Máte dvě služby (bookstack a bookstack_db ), a to jak s obrázky, tak s připojením vazby. Bookstack kontejner má mapování portu z hostitelského portu 8080 na interní port 80.

Vzhledem k extrémně nízké režii kontejnerů Docker je běžnou praxí definovat pro každou webovou aplikaci samostatný databázový kontejner. To umožňuje větší oddělení povinností. To se výrazně liší od tradičních nastavení databáze, kde jediná instalace databáze může obsloužit stovky webových aplikací.

Jedna nová možnost, kterou můžete vidět ve výše uvedeném souboru, je depends_on příkaz. Tento příkaz říká Dockeru pořadí, ve kterém by se měly kontejnery spustit. Definování depends_on příkaz říká Dockeru, že bookstack_db kontejner musí začněte jako první.

Nastavení komunikace kontejneru s proměnnými prostředí

Tento konfigurační soubor vytvořený v poslední sekci ještě není kompletní. I když jste definovali dvě služby (kontejnery), nemluví spolu! bookstack kontejner nemá ponětí, jak komunikovat s bookstack_db kontejner. Pojďme to vyřešit pomocí proměnných prostředí.

Proměnné prostředí jsou nejběžnějším způsobem poskytování proměnných kontejnerům Docker. Toto jsou proměnné zadané za běhu (nebo definované v docker-compose.yaml konfigurační soubor) poskytující informace o tom, co kontejner potřebuje udělat.

Proměnné prostředí definuje osoba, která vytváří image Docker. Budou se lišit v závislosti na obrazu Dockeru, který používáte, a musíte se podívat do dokumentace od tvůrce ohledně toho, jaké proměnné prostředí použít.

Existují dva způsoby definování proměnných prostředí; přímo v docker-compose.yaml soubor samotný nebo jako samostatný soubor.

Samostatný soubor je obvykle doporučenou metodou, zejména pokud proměnné obsahují citlivá data, jako jsou hesla. docker-compose.yaml soubor je navržen ke sdílení nebo dokonce nahrání do veřejně přístupného úložiště GitHub. Samostatný soubor pro citlivá data snižuje možnost náhodného narušení zabezpečení.

Na hostiteli Docker nyní vytvořte dvě proměnné prostředí; jeden pro knihovnu kontejner a jeden pro bookstack_db kontejner.

1. Vytvořte nový soubor v ~/containers/bookstack složku s názvem bookstack.env s následujícím obsahem:

APP_URL is the IP address or hostname of your server. This article is using homelab-docker
 APP_URL=http://homelab-docker:8080
 DB_HOST is the container name you gave your container
 DB_HOST=bookstack_db
 DB_USER is defined in the bookstack_DB environment file
 DB_USER=bookstack_user
 DB_PASS is also defined in the bookstack_DB environment file
 DB_PASS=MySecurePassword
 DB_DATABASE is the name of the database within mariadb
 DB_DATABASE=bookstack

2. Vytvořte nový soubor v ~/containers/bookstack složku s názvem bookstack_db.env a zahrnují následující obsah:

The root password for our database, keep it secret, keep it safe
 MYSQL_ROOT_PASSWORD=MySecureRootPassword
 The database bookstack will be using
 MYSQL_DATABASE=bookstack
 the user bookstack will be using
 MYSQL_USER=bookstack_user
 the password bookstack will be using
 MYSQL_PASSWORD=MySecurePassword

3. Nejlepším postupem je nyní zajistit obě env soubory nejsou čitelné pro ostatní uživatele.

chmod 600 bookstack.env bookstack_db.env

Měli byste změnit přístup pro čtení, protože soubory bookstack.env i bookstack_db.env obsahují citlivá data.

4. Aktualizujte ~/containers/bookstack/docker-compose.yaml Soubor Docker Compose, který odkazuje na tyto dva soubory prostředí zobrazené níže.

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"

5. Nyní spusťte knihovnu a bookstack_db kontejnery pomocí Docker Compose.

sudo docker-compose up -d

Každý z výše uvedených kroků v této části můžete vidět v kódu VS níže.

Monitorování protokolů Docker Compose

Engine Docker spolupracuje s Docker Compose a provádí mnoho různých úkolů na pozadí. Schopnost sledovat, co se děje, zejména při práci s více kontejnery najednou, je užitečná.

Chcete-li například sledovat kontejner Bookstack, použijte logs příkaz. Jakmile v tomto tutoriálu uvidíte protokoly [services.d] done , můžete přejít na adresu URL zásobníku.

sudo docker-compose logs bookstack

V této fázi byste měli mít plně funkční wiki spuštěnou ve vlastním kontejneru, s vlastní databází, zcela v Dockeru!

Dokud máte složky bookstack a bookstack_db, můžete své prostředí bookstack znovu vytvořit od začátku.

Docker Compose and Networking

Do této chvíle jste se toho příliš nenaučili o komunikačních a síťových aspektech toho, jak kontejnery spolupracují. Pojďme to změnit.

Když vytvoříte více kontejnerů v rámci jednoho docker-compose.yaml jak jste to udělali v předchozích částech, jsou všechny přiřazeny ke stejné síti (obvykle nazývané název-nadřazené-složky_výchozí ).

Síť vytvořenou pro kontejnery můžete vidět, když spustíte docker-compose up -d jak je uvedeno níže.

Když jsou všechny kontejnery přiřazeny ve stejné síti, Docker pro ně interně vytvoří záznamy DNS. Proto jste v předchozím příkladu označovali svou databázi jako bookstack_db v proměnných prostředí. Ten bookstack_db name je ve skutečnosti záznam DNS, který ukazuje na IP adresu databázového kontejneru.

Také se nemusíte spoléhat na to, že Docker Compose automaticky generuje sítě za vás. Můžete ručně definovat interní nebo externí sítě. Ruční definování sítí je skvělé, když máte kontejner, který potřebuje mluvit s jiným kontejnerem v samostatném docker-compose.yaml soubor. Můžete odhalit porty nebo můžete vytvořit síť, ke které se oba mohou připojit!

Všimněte si, že když začnete explicitně definovat sítě, musíte také explicitně definovat výchozí síť. Jakmile začnete sítě definovat, Docker Compose automaticky zastaví vytváření této sítě

Nyní upravte bookstack docker-compose.yaml zahrnout externě vytvořenou síť.

1. Vytvořte externí síť pomocí docker network create my_external_network .

2. Definujte externí síť v docker-compose.yaml :

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
     networks:
       - "my_external_network"
       - "bookstack_default"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"
     networks:
       - "bookstack_default"
 networks:
   bookstack_default:
   my_external_network:
     external: true

3. Spusťte docker-compose up -d znovu vytvořit kontejnery. Vaše dva kontejnery jsou nyní připojeny ke dvěma sítím, jak je znázorněno níže.

Kontejner Bookstack je nyní také připojen k externě definované síti. To vám umožní vytvořit další kontejner, který změní HTTP provoz knihoven na HTTPS, než opustí Docker (označovaný jako reverse-proxy ).

Nastavení konkrétního uživatele pro spuštění kontejneru

Ve výchozím nastavení všechny kontejnery Docker běží jako uživatel root v sandboxu. To je ekvivalentní spuštění virtuálního počítače přihlášeného jako výchozí uživatel správce. Zatímco toto obecně není problém, pokud je karanténa ohrožena, existují obavy o bezpečnost.

Dalším problémem se spuštěním jako root jsou oprávnění k souboru. Můžete si všimnout, že pokud se pokusíte odstranit db složky v knihovně složku, ve skutečnosti nemůžete; obsah je ve vlastnictví root.

Zatímco většina obrázků neocení běh jako uživatel bez oprávnění root, linuxserver.io obrázky zejména nabízejí proměnnou prostředí pro nastavení uživatele, který běží uvnitř kontejneru. Můžete tak učinit přidáním UID=1000 a GID=1000 uvnitř bookstack.env konfigurace.

1000:1000 je výchozí uživatelské ID a skupina pro prvního uživatele v ubuntu (což možná nejste). You can read more about User IDs and Group IDs at Related:A Windows Guy in a Linux World:Users and File Permissions )

You can also force a UID and GID using the user parameter in docker-compose, but this is not recommended as most containers do not behave well when forced to a different user

Setting the Restart Policy

If you’d like containers built with Docker Compose to restart on failure, use the restart policy by adding a restart: <option> parameter under the container settings in docker-compose.yaml .

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

Adding this parameter will cause containers to automatically restart on failure to help maintain uptime in the event of unexpected power issues.

Manually setting DNS entries for Containers

Just like with Windows and Linux, Docker also has a “hosts file”. By using the extra_hosts parameter in a config file, you can force a host to resolve to a specific IP. This can be useful when you have DNS constraints, such as split DNS or a test server you want to interact with temporarily.

extra_hosts:
  - "somehost:x.x.x.x"
  - "otherhost:x.x.x.x"

Running Commands

Once the container is started, you can run commands inside of the container using the docker-compose run . For example, maybe you’d like to start up a Bash terminal inside of your bookstack kontejner. To do that, you’d run the command below.

docker-compose run web bash

Závěr

At this stage, you should have enough information to follow along with the majority of docker-compose tutorials out on the web. Having this knowledge can vastly expand your ability to move into the world of Docker, and the building of web apps in Infrastructure as Code.