GNU/Linux >> Znalost Linux > >> Panels >> Docker

Jak připojit kontejnery Docker

<šablona x-if=visible><šablona x-if=$isMobile()>

Při použití Dockeru ke kontejnerizaci aplikací je běžnou praxí spouštět každou komponentu aplikace v samostatném kontejneru. Webová stránka může mít například webový server, aplikaci a databázi, z nichž každá běží ve svém vlastním kontejneru.

Konfigurace kontejnerů tak, aby komunikovaly mezi sebou a hostitelským počítačem, může být problém. Tato příručka bude na jednoduchém příkladu aplikace demonstrovat základy kontejnerové komunikace Docker. Aplikace se bude skládat z aplikace Node.js, která čte data z databáze PostgreSQL.

Než začnete

Instalovat Docker CE

Abyste mohli postupovat podle kroků v této příručce, budete potřebovat Linode s nainstalovaným Docker CE.

Chcete-li nainstalovat Docker CE (Community Edition), postupujte podle pokynů v jedné z níže uvedených příruček:

Instalace a používání Dockeru na Ubuntu a Debian
Instalace a používání Dockeru na CentOS a Fedoře

Úplné pokyny pro ještě více distribucí Linuxu naleznete v části Instalace Docker Engine v oficiální dokumentaci Dockeru.

Ukázková aplikace Node.js

Vzorová aplikace použitá v této příručce bude jednoduchá aplikace Node.js, která přečte „Hello world“ z databáze PostgreSQL a vytiskne ji do konzole. V této části vytvoříte a otestujete aplikaci na svém Linode bez použití kontejnerů.

Instalace a konfigurace PostgreSQL

Aktualizujte svůj systém:
```
sudo apt update && sudo apt upgrade
```

Nainstalujte PostGreSQL:

sudo apt install postgresql postgresql-contrib

Změňte postgres uživatelské heslo:
```
sudo passwd postgres
```

Nastavte heslo pro postgres uživatel databáze:

su - postgres
psql -d template1 -c "ALTER USER postgres WITH PASSWORD 'newpassword';"

Vytvořte databázi pro ukázkovou aplikaci a připojte se k ní:
```
createdb nodejs
psql nodejs
```

Přidejte „Hello world“ do databáze:

nodejs=# CREATE TABLE hello (message varchar);
nodejs=# INSERT INTO hello VALUES ('Hello world');
nodejs=# \q

Vytvořte výpis databáze pro pozdější použití:
```
pg_dumpall > backup.sql
```
Odhlaste se jako postgres Uživatel Linuxu:
```
exit
```
Zkopírujte výpis dat do svého domovského adresáře:
```
sudo cp /var/lib/postgresql/backup.sql ~/.
```

Protože se k této databázi budete připojovat z kontejneru (který bude mít jinou IP adresu než locahost ), budete muset upravit konfigurační soubor PostgreSQL, abyste povolili připojení ze vzdálených adres. Otevřete /etc/postgresql/9.5/main/postgresql.conf v textovém editoru. Odkomentujte listen_addresses řádek a nastavte jej na „*“:

Soubor:/ etc/postgresql/9.5/main/postgresql.conf

#------------------------------------------------------------------------------
# CONNECTIONS AND AUTHENTICATION
#------------------------------------------------------------------------------

# - Connection Settings -

listen_addresses = '*'                  # what IP address(es) to listen on;

Povolte a spusťte postgresql služba:

sudo systemctl enable postgresql
sudo systemctl start postgresql

Vytvořit aplikaci Hello World

Nainstalujte Node a NPM:

curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
sudo apt-get install nodejs

Přejděte do domovského adresáře a vytvořte adresář:
```
cd
mkdir app && cd app
```

Pomocí textového editoru vytvořte app.js a přidejte následující obsah:

Soubor:app .js

const { Client } = require('pg')

const client = new Client({
  user: 'postgres',
  host: 'localhost',
  database: 'nodejs',
  password: 'newpassword',
  port: 5432
})

client.connect()

client.query('SELECT * FROM hello', (err, res) => {
  console.log(res.rows[0].message)
  client.end()
})

Tato aplikace používá pg Modul NPM (node-postgres) pro připojení k databázi vytvořené v předchozí části. Poté se dotazuje na tabulku „ahoj“ (která vrací zprávu „Ahoj světe“) a zaznamenává odpověď do konzole. Nahraďte 'newpassword' pomocí postgres heslo uživatele databáze, které jste nastavili v předchozí části.

Poznámka pg modul může také používat proměnné prostředí ke konfiguraci připojení klienta. Toto je doporučená možnost pro produkční aplikace. Přečtěte si více o proměnných prostředí v dokumentaci thenode-postgres.

Nainstalujte pg modul:
```
npm install pg
```
Otestujte aplikaci:
```
node app.js
```
Pokud je databáze správně nakonfigurována, na konzoli se zobrazí „Hello world“.

Připojit kontejner k hostiteli Docker

Tato část ilustruje případ použití, kdy se aplikace Node.js spouští z kontejneru Docker a připojuje se k databázi spuštěné na hostiteli Docker.

Nastavit kontejner Docker

Návrat do domovského adresáře:
```
cd
```

Vytvořte Dockerfile pro spuštění aplikace Node.js:

Soubor:Dockerfile

FROM debian

RUN apt update -y && apt install -y gnupg curl
RUN curl -sL https://deb.nodesource.com/setup_8.x | bash - && apt install -y nodejs
COPY app/ /home/

ENTRYPOINT tail -F /dev/null

Obrázek vytvořený z tohoto Dockerfile zkopíruje app/ adresáře do nového obrázku. Upravte app.js aby se aplikace mohla připojit k database hostitel místo localhost :
Soubor:app /app.js
1 2 3 4 5 6 7

const client = new Client({ user: 'postgres', host: 'database', database: 'nodejs', password: 'newpassword', port: 5432 })
Vytvořte obrázek z Dockerfile:
```
docker build -t node_image .
```

Připojit kontejner k databázi

Docker automaticky nastaví výchozí síť mostu , přístupný přes docker0 síťové rozhraní. Použijte ifconfig nebo ip k zobrazení tohoto rozhraní:

ifconfig docker0

Výstup bude vypadat následovně:

docker0   Link encap:Ethernet  HWaddr 02:42:1e:e8:39:54
  inet addr:172.17.0.1  Bcast:0.0.0.0  Mask:255.255.0.0
  inet6 addr: fe80::42:1eff:fee8:3954/64 Scope:Link
  UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
  RX packets:3848 errors:0 dropped:0 overruns:0 frame:0
  TX packets:5084 errors:0 dropped:0 overruns:0 carrier:0
  collisions:0 txqueuelen:0
  RX bytes:246416 (246.4 KB)  TX bytes:94809688 (94.8 MB)

Interní IP adresa hostitele Docker (váš Linode) je 172.17.0.1.

Povolit PostgreSQL přijímat připojení z rozhraní Docker. Otevřete /etc/postgresql/9.5/main/pg_hba.conf v textovém editoru a přidejte následující řádek:
Soubor:/ etc/postgresql/9.5/main/pg_hba.conf
1

host all postgres 172.17.0.0/16 password
Protože 172.17.0.1 je IP hostitele Dockeru, všechny kontejnery na hostiteli budou mít IP adresu v rozsahu 172.17.0.0/16.
Restartujte databázi:
```
sudo systemctl restart postgresql
```
Spusťte kontejner:
```
docker run -d --add-host=database:172.17.0.1 --name node_container node_image
```
--add-host volba definuje database hostitel, který ukazuje na IP adresu hostitele Docker. Deklarace database hostitel za běhu, namísto pevného kódování IP adresy v aplikaci, pomáhá udržovat kontejner znovupoužitelný.
Z kontejneru použijte ping pro otestování připojení k database hostitel:
```
docker exec -it node_container ping database
```
Každý kontejner Docker má také přiřazenu vlastní IP adresu z bloku 172.17.0.0/16. Najděte IP adresu tohoto kontejneru pomocí ip :
```
docker exec -it node_container ip addr show eth0
```
Toto připojení můžete otestovat pomocí příkazu ping na tuto adresu z hostitele Docker.

Spusťte aplikaci:

docker exec -it node_container node home/app.js

Pokud byla konfigurace úspěšná, program by měl zobrazit výstup konzoly „Hello world“ jako předtím.

Propojit dva kontejnery

V této části budou aplikace i databáze spuštěny v samostatných kontejnerech. Můžete použít oficiální postgresovou bitovou kopii z Docker Hub a načíst ji do výpisu SQL vytvořeného dříve.

Pozor Data produkční databáze byste neměli ukládat do kontejneru Docker. S kontejnery by se mělo zacházet jako s pomíjivými entitami:pokud kontejner neočekávaně havaruje nebo je restartován, všechna data v databázi budou ztracena.

Zastavte a odeberte kontejner Node.js:

docker stop node_container
docker rm node_container

Vytáhněte postgres obrázek:
```
docker pull postgres
```
Ujistěte se, že váš backup.sql soubor je ve vašem aktuálním pracovním adresáři, pak spusťte postgres obrázek:
```
docker run -d -v `pwd`:/backup/ --name pg_container postgres
```
-v volba připojí váš aktuální pracovní adresář k /backup/ adresář v novém kontejneru.
Nový kontejner automaticky spustí databázi postgres a vytvoří uživatele postgres. Zadejte kontejner a načtěte výpis SQL:
```
docker exec -it pg_container bash
cd backup
psql -U postgres -f backup.sql postgres
exit
```
Spusťte znovu obraz uzlu. Tentokrát místo --add-host , použijte --link možnost připojení kontejneru k pg_container:
```
docker run -d --name node_container --link=pg_container:database node_image
```
Tím se propojí pg_container pod názvem hostitele database .
Otevřete /etc/hosts v node_container, abyste potvrdili, že byl odkaz vytvořen:
```
docker exec -it node_container cat /etc/hosts
```
Měl by tam být řádek podobný následujícímu:
Soubor:/ etc/hosts
```
172.17.0.2  database  pg_container
```
To ukazuje, že pg_container byla přiřazena k IP adrese 172.17.0.2 a je propojena s tímto kontejnerem prostřednictvím hostitele database podle očekávání.
Protože aplikace Node.js stále očekává připojení k databázi PostgreSQL v database hostitele, nejsou nutné žádné další změny. Měli byste být schopni spustit aplikaci jako dříve:
```
docker exec -it node_container node home/app.js
```

Používání Docker Compose

Pomocí --link nebo --host možnosti při každém spuštění kontejnerů mohou být těžkopádné. Pokud váš server nebo některý z kontejnerů selže, je nutné je znovu ručně připojit. To není ideální situace pro žádnou aplikaci, která vyžaduje stálou dostupnost. Naštěstí Docker poskytuje Docker Compose pro správu více kontejnerů a jejich automatické propojení při jejich spuštění. Tato část použije Docker Compose k reprodukci výsledků předchozí části.

Poznámka Pro obsáhlejší vysvětlení Docker Compose a jak psát docker-compose.yml konfigurační soubory, viz naši kompletní příručku Docker Compose.

Nainstalujte Docker Compose:

sudo curl -L https://github.com/docker/compose/releases/download/1.17.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Ve stejném adresáři jako váš Dockerfile vytvořte docker-compose.yml soubor s následujícím obsahem:

Soubor:docker -compose.yml

version: '3'

services:
  database:
    image: postgres
    container_name: pg_container
    volumes:
       - pgdata:/var/lib/postgresql/data

  app:
    build: .
    container_name: node_container
    links:
     - database
    environment:
      - PGPASSWORD=newpassword
      - PGUSER=postgres
      - PGDATABASE=nodejs
      - PGHOST=database
      - PGPORT=5432
    depends_on:
      - database

volumes:
  pgdata: {}

Když spustíte Docker Compose s tímto souborem, vytvoří se pg_container a node_container z předchozí části. Stejně jako dříve bude databázový kontejner používat oficiální obrázek PostgreSQL, zatímco kontejner aplikace bude vytvořen z vašeho Dockerfile. links záznam má stejnou funkci jako --link možnost v run dříve použitý příkaz.

Docker Compose vám také umožňuje nastavit hodnoty prostředí, takže můžete aplikaci zjednodušit, aby je používala, místo abyste měli hodnoty pevně zakódované. Upravte app.js k odstranění těchto hodnot:

Soubor:app .js

const express = require('express')
const { Client } = require('pg')

const client = new Client()

client.connect()

client.query('SELECT * FROM hello', (err, res) => {
  console.log(res.rows[0].message)
  client.end()
})

Odstraňte předchozí kontejnery:

docker rm -f node_container pg_container

Pomocí Docker Compose vyvolejte kontejnery:
```
docker-compose up -d
```

Načtěte ukázková data do nového kontejneru:

docker cp backup.sql pg_container:/
docker exec -it pg_container psql -U postgres -f backup.sql postgres

Spusťte app.js z kontejneru aplikace:

docker exec -it node_container node home/app.js

Aplikace by měla běžet jako předtím.

Závěr

Ve výchozím nastavení Docker automaticky přiřadí IP adresu každému kontejneru a hostiteli Dockeru. Služby mezi kontejnery můžete ručně propojit pomocí těchto adres (za předpokladu, že váš firewall připojení umožňuje).

Docker však kolem těchto připojení poskytuje také řadu pohodlných obalů, které vám pomohou urychlit a zjednodušit proces připojení. Hostitele Dockeru můžete připojit ke kontejneru s jedinečným názvem hostitele nebo přímo propojit dva kontejnery. Použití Docker Compose může tento proces ještě více zjednodušit tím, že vám umožní deklarovat připojení v docker-compose.yml tak, aby byly automaticky vytvořeny, když jsou kontejnery vyvolány.

Existují další možnosti připojení, které nejsou uvedeny v této příručce. Můžete například spustit kontejner pomocí --net="host" , který bude sdílet síťový zásobník tohoto kontejneru s hostitelem Docker:localhost na kontejneru bude ukazovat na localhost na hostiteli Docker. Můžete také vystavit porty na každém kontejneru Docker nebo nakonfigurovat výchozí síť mostu pro větší flexibilitu. Pro podrobnější diskusi o těchto možnostech se podívejte na odkazy v části Další informace níže.

Další informace

Další informace o tomto tématu můžete získat v následujících zdrojích. Přestože jsou poskytovány v naději, že budou užitečné, vezměte prosím na vědomí, že nemůžeme ručit za přesnost nebo aktuálnost externě hostovaných materiálů.

Docker:Pochopení kontejnerové komunikace
Propojení kontejnerů
Připojování kontejnerů

Jak používat Docker Compose Jak nasadit aplikace s Rancherem

Docker