GNU/Linux >> Belajar Linux > >> Panels >> Docker

Bagaimana Menghubungkan Kontainer Docker

Saat menggunakan Docker untuk menyimpan aplikasi Anda, adalah praktik umum untuk menjalankan setiap komponen aplikasi dalam wadah terpisah. Misalnya, sebuah situs web mungkin memiliki server web, aplikasi, dan database, masing-masing berjalan dalam wadahnya sendiri.

Mengonfigurasi wadah untuk berkomunikasi satu sama lain dan mesin host dapat menjadi tantangan. Panduan ini akan menggunakan aplikasi contoh sederhana untuk mendemonstrasikan dasar-dasar komunikasi container Docker. Aplikasi ini akan terdiri dari aplikasi Node.js yang membaca data dari database PostgreSQL.

Sebelum Anda Mulai

Instal Docker CE

Anda memerlukan Linode dengan Docker CE yang diinstal untuk mengikuti langkah-langkah dalam panduan ini.

Untuk menginstal Docker CE (Edisi Komunitas), ikuti petunjuk dalam salah satu panduan di bawah ini:

Menginstal dan Menggunakan Docker di Ubuntu dan Debian
Memasang dan Menggunakan Docker di CentOS dan Fedora

Untuk petunjuk lengkap tentang distribusi Linux lainnya, lihat bagian Instal Docker Engine dari dokumentasi resmi Docker.

Contoh Aplikasi Node.js

Contoh aplikasi yang digunakan dalam panduan ini adalah aplikasi Node.js sederhana yang akan membaca "Hello world" dari database PostgreSQL dan mencetaknya ke konsol. Di bagian ini, Anda akan membuat dan menguji aplikasi di Linode tanpa menggunakan container.

Instal dan Konfigurasi PostgreSQL

Perbarui sistem Anda:
```
sudo apt update && sudo apt upgrade
```

Instal PostGreSQL:

sudo apt install postgresql postgresql-contrib

Ubah postgres kata sandi pengguna:
```
sudo passwd postgres
```

Tetapkan kata sandi untuk postgres pengguna basis data:

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

Buat database untuk aplikasi contoh dan sambungkan ke sana:
```
createdb nodejs
psql nodejs
```

Tambahkan "Halo dunia" ke database:

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

Buat dump database untuk digunakan nanti:
```
pg_dumpall > backup.sql
```
Keluar sebagai postgres Pengguna Linux:
```
exit
```

Salin dump data ke direktori home Anda:

sudo cp /var/lib/postgresql/backup.sql ~/.

Karena Anda akan terhubung ke database ini dari wadah (yang akan memiliki alamat IP selain locahost ), Anda perlu mengedit file konfigurasi PostgreSQL untuk mengizinkan koneksi dari alamat jarak jauh. Buka /etc/postgresql/9.5/main/postgresql.conf dalam editor teks. Batalkan komentar pada listen_addresses baris dan atur ke '*':

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

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

# - Connection Settings -

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

Aktifkan dan mulai postgresql layanan:

sudo systemctl enable postgresql
sudo systemctl start postgresql

Buat Aplikasi Hello World

Instal Node dan NPM:

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

Arahkan ke direktori home dan buat direktori:
```
cd
mkdir app && cd app
```

Menggunakan editor teks, buat app.js dan tambahkan konten berikut:

File: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()
})

Aplikasi ini menggunakan pg Modul NPM (node-postgres) untuk terhubung ke database yang dibuat di bagian sebelumnya. Ini kemudian menanyakan tabel 'halo' (yang mengembalikan pesan "Halo dunia") dan mencatat respons ke konsol. Ganti 'newpassword' dengan postgres kata sandi pengguna basis data yang Anda atur di bagian sebelumnya.

Catatan pg modul juga dapat menggunakan variabel lingkungan untuk mengkonfigurasi koneksi klien. Ini adalah opsi yang disarankan untuk aplikasi produksi. Baca lebih lanjut tentang variabel lingkungan dalam dokumentasi thenode-postgres.

Instal pg modul:
```
npm install pg
```
Uji aplikasi:
```
node app.js
```
Jika database dikonfigurasi dengan benar, “Hello world” akan ditampilkan di konsol.

Hubungkan Penampung ke Host Docker

Bagian ini mengilustrasikan kasus penggunaan di mana aplikasi Node.js dijalankan dari container Docker, dan terhubung ke database yang berjalan di host Docker.

Menyiapkan Kontainer Docker

Kembali ke direktori home Anda:
```
cd
```

Buat Dockerfile untuk menjalankan aplikasi Node.js:

File: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

Gambar yang dibuat dari Dockerfile ini akan menyalin app/ direktori ke gambar baru. Edit app.js untuk mengizinkan aplikasi terhubung ke database host bukannya localhost :
File:app /app.js
1 2 3 4 5 6 7

const client = new Client({ user: 'postgres', host: 'database', database: 'nodejs', password: 'newpassword', port: 5432 })
Buat gambar dari Dockerfile:
```
docker build -t node_image .
```

Hubungkan Kontainer ke Database

Docker secara otomatis menyiapkan jaringan jembatan default , diakses melalui docker0 antarmuka jaringan. Gunakan ifconfig atau ip untuk melihat antarmuka ini:

ifconfig docker0

Outputnya akan seperti berikut:

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)

Alamat IP internal host Docker (Linode Anda) adalah 172.17.0.1.

Izinkan PostgreSQL untuk menerima koneksi dari antarmuka Docker. Buka /etc/postgresql/9.5/main/pg_hba.conf di editor teks dan tambahkan baris berikut:
File:/ etc/postgresql/9.5/main/pg_hba.conf
1

host all postgres 172.17.0.0/16 password
Karena 172.17.0.1 adalah IP dari host Docker, semua container pada host akan memiliki alamat IP dalam kisaran 172.17.0.0/16.
Mulai ulang basis data:
```
sudo systemctl restart postgresql
```
Mulai penampung:
```
docker run -d --add-host=database:172.17.0.1 --name node_container node_image
```
--add-host opsi mendefinisikan database host, yang menunjuk ke alamat IP dari host Docker. Mendeklarasikan database host saat runtime, alih-alih mengkodekan alamat IP di aplikasi secara hard-coding, membantu menjaga container dapat digunakan kembali.
Dari dalam wadah, gunakan ping untuk menguji koneksi ke database tuan rumah:
```
docker exec -it node_container ping database
```
Setiap wadah Docker juga diberi alamat IP sendiri dari dalam blok 172.17.0.0/16. Temukan alamat IP wadah ini dengan ip :
```
docker exec -it node_container ip addr show eth0
```
Anda dapat menguji koneksi ini dengan melakukan ping ke alamat ini dari host Docker.

Jalankan aplikasi:

docker exec -it node_container node home/app.js

Jika konfigurasi berhasil, program akan menampilkan output konsol “Hello world” seperti sebelumnya.

Hubungkan Dua Kontainer

Di bagian ini, aplikasi dan database akan berjalan dalam wadah terpisah. Anda dapat menggunakan image postgres resmi dari Docker Hub dan memuat di SQL dump yang dibuat sebelumnya.

Hati-hati Anda tidak boleh menyimpan data database produksi di dalam wadah Docker. Penampung harus diperlakukan sebagai entitas sementara:jika penampung tiba-tiba mogok atau dimulai ulang, semua data dalam database akan hilang.

Hentikan dan hapus wadah Node.js:

docker stop node_container
docker rm node_container

Tarik postgres gambar:
```
docker pull postgres
```
Pastikan backup.sql Anda file ada di direktori kerja Anda saat ini, lalu jalankan postgres gambar:
```
docker run -d -v `pwd`:/backup/ --name pg_container postgres
```
-v opsi memasang direktori kerja Anda saat ini ke /backup/ direktori pada wadah baru.
Wadah baru akan secara otomatis memulai database postgres dan membuat pengguna postgres. Masukkan wadah dan muat SQL dump:
```
docker exec -it pg_container bash
cd backup
psql -U postgres -f backup.sql postgres
exit
```
Jalankan gambar simpul lagi. Kali ini, alih-alih --add-host , gunakan --link opsi untuk menghubungkan wadah ke pg_container:
```
docker run -d --name node_container --link=pg_container:database node_image
```
Ini akan menautkan pg_container di bawah nama host database .
Buka /etc/hosts di node_container untuk mengonfirmasi bahwa tautan telah dibuat:
```
docker exec -it node_container cat /etc/hosts
```
Seharusnya ada baris yang mirip dengan berikut ini:
File:/ dll/host
```
172.17.0.2  database  pg_container
```
Ini menunjukkan bahwa pg_container telah ditetapkan ke alamat IP 172.17.0.2, dan ditautkan ke wadah ini melalui nama host database , seperti yang diharapkan.
Karena aplikasi Node.js masih mengharapkan untuk terhubung ke database PostgreSQL di database tuan rumah, tidak ada perubahan lebih lanjut yang diperlukan. Anda harus dapat menjalankan aplikasi seperti sebelumnya:
```
docker exec -it node_container node home/app.js
```

Menggunakan Docker Compose

Menggunakan --link atau --host opsi setiap kali Anda meluncurkan wadah Anda bisa menjadi rumit. Jika server Anda atau salah satu container mogok, mereka harus disambungkan kembali secara manual. Ini bukan situasi yang ideal untuk aplikasi apa pun yang membutuhkan ketersediaan konstan. Untungnya, Docker menyediakan Docker Compose untuk mengelola beberapa wadah dan secara otomatis menautkannya bersama-sama saat diluncurkan. Bagian ini akan menggunakan Docker Compose untuk mereproduksi hasil dari bagian sebelumnya.

Catatan Untuk penjelasan yang lebih komprehensif tentang Docker Compose dan cara menulis docker-compose.yml file konfigurasi, lihat panduan Compose Docker kami yang lengkap.

Instal Penulisan Docker:

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

Di direktori yang sama dengan file Docker Anda, buat docker-compose.yml file dengan konten berikut:

File:buruh pelabuhan -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: {}

Saat Anda menjalankan Docker Compose dengan file ini, itu akan membuat pg_container dan node_container dari bagian sebelumnya. Seperti sebelumnya, wadah basis data akan menggunakan gambar PostgreSQL resmi, sedangkan wadah aplikasi akan dibuat dari Dockerfile Anda. links entri memiliki fungsi yang sama dengan --link opsi di run perintah yang digunakan sebelumnya.

Docker Compose juga memungkinkan Anda untuk mengatur nilai lingkungan, sehingga Anda dapat menyederhanakan aplikasi untuk menggunakannya daripada memiliki nilai yang dikodekan secara keras. Edit app.js untuk menghapus nilai ini:

File: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()
})

Hapus wadah sebelumnya:

docker rm -f node_container pg_container

Gunakan Docker Compose untuk membuka container:
```
docker-compose up -d
```

Muat data contoh ke dalam wadah baru:

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

Jalankan app.js dari wadah aplikasi:

docker exec -it node_container node home/app.js

Aplikasi harus berjalan seperti sebelumnya.

Kesimpulan

Secara default, Docker secara otomatis memberikan alamat IP ke setiap wadah dan ke host Docker. Anda dapat menghubungkan layanan antar container secara manual dengan menggunakan alamat ini (dengan asumsi firewall Anda mengizinkan koneksi).

Namun, Docker juga menyediakan sejumlah pembungkus yang nyaman di sekitar koneksi ini untuk membantu Anda mempercepat dan menyederhanakan proses koneksi. Anda dapat menghubungkan host Docker Anda ke sebuah wadah dengan nama host yang unik, atau langsung menautkan dua wadah. Menggunakan Docker Compose dapat menyederhanakan proses ini lebih jauh lagi dengan mengizinkan Anda mendeklarasikan koneksi di docker-compose.yml file sehingga mereka secara otomatis dibuat ketika kontainer dibawa.

Ada opsi koneksi lain yang tidak tercakup dalam panduan ini. Misalnya, Anda dapat menjalankan wadah menggunakan --net="host" , yang akan membagikan tumpukan jaringan penampung itu dengan host Docker:localhost pada wadah akan menunjuk ke localhost pada host Docker. Anda juga dapat mengekspos port pada setiap wadah Docker, atau mengonfigurasi jaringan jembatan default untuk lebih banyak fleksibilitas. Untuk diskusi lebih mendalam tentang opsi ini, lihat tautan di bagian Info Lebih Lanjut di bawah.

Informasi Lebih Lanjut

Anda mungkin ingin berkonsultasi dengan sumber daya berikut untuk informasi tambahan tentang topik ini. Meskipun ini disediakan dengan harapan dapat bermanfaat, harap perhatikan bahwa kami tidak dapat menjamin keakuratan atau ketepatan waktu materi yang dihosting secara eksternal.

Docker:Memahami Komunikasi Kontainer
Menautkan Kontainer
Menghubungkan Kontainer

Cara Menggunakan Tulis Docker Cara Menyebarkan Aplikasi dengan Rancher

Docker