🥇Przewodnik dla początkujących dotyczący tworzenia Dockera

Autor artykułu, którego tłumaczenie dzisiaj publikujemy, twierdzi, że jest on przeznaczony dla tych programistów, którzy chcą nauczyć się Docker Compose i są na drodze do stworzenia swojej pierwszej aplikacji klient-serwer z wykorzystaniem Dockera. Zakłada się, że czytelnik tego materiału jest zaznajomiony z podstawami Dockera. Jeśli tak nie jest, możesz rzucić okiem to seria materiałów dot to post obejmujący podstawy Dockera wraz z podstawami Kubernetesa, oraz to artykuł dla początkujących.

Co to jest Docker Compose?

Docker Compose to narzędzie dołączone do Dockera. Przeznaczony jest do rozwiązywania problemów związanych z wdrażaniem projektów.

Ucząc się podstaw Dockera, być może zetknąłeś się z tworzeniem najprostszych aplikacji, które działają autonomicznie, nie uzależniając się np. od zewnętrznych źródeł danych czy określonych usług. W praktyce takie zastosowania są rzadkością. Prawdziwe projekty zwykle obejmują cały zestaw aplikacji współpracujących.

Skąd wiesz, czy podczas wdrażania projektu musisz użyć Docker Compose? To naprawdę bardzo proste. Jeśli do uruchomienia tego projektu używasz wielu usług, przydatny może być Docker Compose. Na przykład w sytuacji, gdy tworzą stronę internetową, która musi połączyć się z bazą danych, aby uwierzytelnić użytkowników. Taki projekt może składać się z dwóch usług – jednej zapewniającej działanie serwisu oraz drugiej odpowiedzialnej za obsługę bazy danych.

Technologia Docker Compose, jeśli można to opisać w uproszczeniu, pozwala na uruchomienie wielu usług jednym poleceniem.

Różnica między Dockerem a Docker Compose

Docker służy do zarządzania pojedynczymi kontenerami (usługami) tworzącymi aplikację.

Docker Compose służy do zarządzania wieloma kontenerami będącymi jednocześnie częścią aplikacji. Narzędzie to oferuje te same funkcje co Docker, ale pozwala na pracę z bardziej złożonymi aplikacjami.

Docker (pojedynczy kontener) i Docker Compose (wiele kontenerów)

Typowy przypadek użycia Docker Compose

Docker Compose to we właściwych rękach bardzo potężne narzędzie, które pozwala szybko wdrażać aplikacje o złożonej architekturze. Teraz przyjrzymy się przykładowi praktycznego zastosowania Docker Compose, którego analiza pozwoli ocenić korzyści, jakie da Ci użycie Docker Compose.

Wyobraź sobie, że jesteś twórcą projektu internetowego. Projekt obejmuje dwie strony internetowe. Pierwsza pozwala przedsiębiorcom stworzyć za pomocą kilku kliknięć sklepy internetowe. Drugi ma na celu obsługę klienta. Te dwie witryny współdziałają z tą samą bazą danych.

Twój projekt staje się coraz bardziej popularny i okazuje się, że pojemność serwera, na którym działa, nie jest już wystarczająca. W rezultacie decydujesz się na przeniesienie całego projektu na inną maszynę.

Niestety nie użyłeś czegoś takiego jak Docker Compose. Dlatego będziesz musiał przenosić i rekonfigurować usługi pojedynczo, mając nadzieję, że o niczym nie zapomnisz w trakcie tej pracy.

Jeśli korzystasz z Docker Compose, migracja projektu na nowy serwer to problem, który można rozwiązać, uruchamiając kilka poleceń. Aby zakończyć przeniesienie projektu do nowej lokalizacji wystarczy dokonać kilku ustawień i wgrać kopię zapasową bazy danych na nowy serwer.

Tworzenie aplikacji klient-serwer przy użyciu Docker Compose

Skoro już wiesz, do czego będziemy używać Docker Compose, czas stworzyć swoją pierwszą aplikację klient-serwer za pomocą tego narzędzia. Mianowicie mówimy o stworzeniu małej strony internetowej (serwera) w Pythonie, która może wygenerować plik z fragmentem tekstu. Plik ten jest żądany z serwera przez program (klient), również napisany w Pythonie. Po odebraniu pliku z serwera program wyświetla na ekranie zapisany w nim tekst.

Pamiętaj, że zakładamy, że znasz podstawy Dockera i masz już zainstalowaną platformę Docker.

Rozpoczynamy pracę nad projektem.

▍1. Tworzenie projektu

Aby zbudować swoją pierwszą aplikację klient/serwer, sugeruję zacząć od utworzenia folderu projektu. Powinien zawierać następujące pliki i foldery:

plik docker-compose.yml. Jest to plik Docker Compose, który będzie zawierał instrukcje potrzebne do uruchomienia i skonfigurowania usług.
Folder server. Będzie zawierał pliki niezbędne do utrzymania działania serwera.
Folder client. W tym miejscu będą zlokalizowane pliki aplikacji klienckiej.

W rezultacie zawartość głównego folderu Twojego projektu powinna wyglądać następująco:

.
├── client/
├── docker-compose.yml
└── server/
2 directories, 1 file

▍2. Tworzenie serwera

Tutaj, w procesie tworzenia serwera, poruszymy kilka podstawowych kwestii związanych z Dockerem.

2a. Tworzenie plików

Przejdź do folderu server i utwórz w nim następujące pliki:

plik server.py. Będzie zawierał kod serwera.
plik index.html. Plik ten będzie zawierał fragment tekstu, który powinien wyświetlić aplikacja kliencka.
plik Dockerfile. To jest plik Dockera, który będzie zawierał instrukcje potrzebne do stworzenia środowiska serwerowego.

Tak powinna wyglądać zawartość Twojego folderu server/:

.
├── Dockerfile
├── index.html
└── server.py
0 directories, 3 files

2b. Edycja pliku Pythona.

Dodaj do pliku server.py następujący kod:

#!/usr/bin/env python3

# Импорт системных библиотек python.
# Эти библиотеки будут использоваться для создания веб-сервера.
# Вам не нужно устанавливать что-то особенное, эти библиотеки устанавливаются вместе с Python.

import http.server
import socketserver

# Эта переменная нужна для обработки запросов клиента к серверу.

handler = http.server.SimpleHTTPRequestHandler

# Тут мы указываем, что сервер мы хотим запустить на порте 1234. 
# Постарайтесь запомнить эти сведения, так как они нам очень пригодятся в дальнейшем, при работе с docker-compose.

with socketserver.TCPServer(("", 1234), handler) as httpd:

    # Благодаря этой команде сервер будет выполняться постоянно, ожидая запросов от клиента.

   httpd.serve_forever()

Ten kod pozwala na utworzenie prostego serwera WWW. Przekaże klientom akta index.html, którego treść zostanie później wyświetlona na stronie internetowej.

2c. Edycja pliku HTML

Do pliku index.html dodaj następujący tekst:

Docker-Compose is magic!

Ten tekst zostanie wysłany do klienta.

2d. Edytowanie pliku Dockerfile

Teraz utworzymy prosty plik Dockerfile, który będzie odpowiedzialny za organizację środowiska uruchomieniowego dla serwera Python. Jako podstawę utworzonego obrazu użyjemy oficjalnie, przeznaczony do uruchamiania programów napisanych w języku Python. Oto zawartość pliku Dockerfile:

# На всякий случай напоминаю, что Dockerfile всегда должен начинаться с импорта базового образа.
# Для этого используется ключевое слово 'FROM'.
# Здесь нам нужно импортировать образ python (с DockerHub).
# В результате мы, в качестве имени образа, указываем 'python', а в качестве версии - 'latest'.

FROM python:latest

# Для того чтобы запустить в контейнере код, написанный на Python, нам нужно импортировать файлы 'server.py' и 'index.html'.
# Для того чтобы это сделать, мы используем ключевое слово 'ADD'.
# Первый параметр, 'server.py', представляет собой имя файла, хранящегося на компьютере.
# Второй параметр, '/server/', это путь, по которому нужно разместить указанный файл в образе.
# Здесь мы помещаем файл в папку образа '/server/'.

ADD server.py /server/
ADD index.html /server/

# Здесь мы воспользуемся командой 'WORKDIR', возможно, новой для вас.
# Она позволяет изменить рабочую директорию образа.
# В качестве такой директории, в которой будут выполняться все команды, мы устанавливаем '/server/'.

WORKDIR /server/

Teraz zacznijmy pracować nad klientem.

▍3. Utwórz klienta

Tworząc kliencką stronę naszego projektu, będziemy po drodze przypominać sobie pewne podstawy Dockera.

3a. Tworzenie plików

Przejdź do folderu projektu client i utwórz w nim następujące pliki:

plik client.py. Tutaj będzie znajdować się kod klienta.
plik Dockerfile. Plik ten pełni tę samą rolę co podobny plik w folderze serwera. Mianowicie zawiera instrukcje opisujące sposób stworzenia środowiska do wykonywania kodu klienta.

W rezultacie twój folder client/ Na tym etapie powinno to wyglądać tak:

.
├── client.py
└── Dockerfile
0 directories, 2 files

3b. Edytowanie pliku Pythona

Dodaj do pliku client.py następujący kod:

#!/usr/bin/env python3

# Импортируем системную библиотеку Python.
# Она используется для загрузки файла 'index.html' с сервера.
# Ничего особенного устанавливать не нужно, эта библиотека устанавливается вместе с Python.

import urllib.request

# Эта переменная содержит запрос к 'http://localhost:1234/'.
# Возможно, сейчас вы задаётесь вопросом о том, что такое 'http://localhost:1234'.
# localhost указывает на то, что программа работает с локальным сервером.
# 1234 - это номер порта, который вам предлагалось запомнить при настройке серверного кода.

fp = urllib.request.urlopen("http://localhost:1234/")

# 'encodedContent' соответствует закодированному ответу сервера ('index.html').
# 'decodedContent' соответствует раскодированному ответу сервера (тут будет то, что мы хотим вывести на экран).

encodedContent = fp.read()
decodedContent = encodedContent.decode("utf8")

# Выводим содержимое файла, полученного с сервера ('index.html').

print(decodedContent)

# Закрываем соединение с сервером.

fp.close()

Dzięki temu kodowi aplikacja kliencka może pobrać dane z serwera i wyświetlić je na ekranie.

3c. Edytowanie pliku Dockerfile

Podobnie jak w przypadku serwera, tworzymy prosty Dockerfile, odpowiedzialny za kształtowanie środowiska, w którym będzie działać aplikacja kliencka Python. Oto kod klienta Dockerfile:

# То же самое, что и в серверном Dockerfile.

FROM python:latest

# Импортируем 'client.py' в папку '/client/'.

ADD client.py /client/

# Устанавливаем в качестве рабочей директории '/client/'.

WORKDIR /client/

▍4. Tworzenie Dockera

Jak zapewne zauważyłeś, stworzyliśmy dwa różne projekty: serwer i klient. Każdy z nich ma swój własny plik Dockerfile. Jak na razie wszystko co się wydarzyło nie wyszło poza podstawy pracy z Dockerem. Teraz możemy przystąpić do pracy z Docker Compose. Aby to zrobić, zapoznaj się z plikiem docker-compose.ymlznajduje się w folderze głównym projektu.

Należy pamiętać, że tutaj nie staramy się omówić absolutnie wszystkich poleceń, których można użyć docker-compose.yml. Naszym głównym celem jest omówienie praktycznego przykładu, który zapewni Ci podstawową wiedzę na temat Docker Compose.

Oto kod do umieszczenia w pliku docker-compose.yml:

# Файл docker-compose должен начинаться с тега версии.
# Мы используем "3" так как это - самая свежая версия на момент написания этого кода.

version: "3"

# Следует учитывать, что docker-composes работает с сервисами.
# 1 сервис = 1 контейнер.
# Сервисом может быть клиент, сервер, сервер баз данных...
# Раздел, в котором будут описаны сервисы, начинается с 'services'.

services:

  # Как уже было сказано, мы собираемся создать клиентское и серверное приложения.
  # Это означает, что нам нужно два сервиса.
  # Первый сервис (контейнер): сервер.
  # Назвать его можно так, как нужно разработчику.
  # Понятное название сервиса помогает определить его роль.
  # Здесь мы, для именования соответствующего сервиса, используем ключевое слово 'server'.

  server:
 
    # Ключевое слово "build" позволяет задать
    # путь к файлу Dockerfile, который нужно использовать для создания образа,
    # который позволит запустить сервис.
    # Здесь 'server/' соответствует пути к папке сервера,
    # которая содержит соответствующий Dockerfile.

    build: server/

    # Команда, которую нужно запустить после создания образа.
    # Следующая команда означает запуск "python ./server.py".

    command: python ./server.py

    # Вспомните о том, что в качестве порта в 'server/server.py' указан порт 1234.
    # Если мы хотим обратиться к серверу с нашего компьютера (находясь за пределами контейнера),
    # мы должны организовать перенаправление этого порта на порт компьютера.
    # Сделать это нам поможет ключевое слово 'ports'.
    # При его использовании применяется следующая конструкция: [порт компьютера]:[порт контейнера]
    # В нашем случае нужно использовать порт компьютера 1234 и организовать его связь с портом
    # 1234 контейнера (так как именно на этот порт сервер 
    # ожидает поступления запросов).

    ports:
      - 1234:1234

  # Второй сервис (контейнер): клиент.
  # Этот сервис назван 'client'.

  client:
    # Здесь 'client/ соответствует пути к папке, которая содержит
    # файл Dockerfile для клиентской части системы.

    build: client/

    # Команда, которую нужно запустить после создания образа.
    # Следующая команда означает запуск "python ./client.py".
 
    command: python ./client.py

    # Ключевое слово 'network_mode' используется для описания типа сети.
    # Тут мы указываем то, что контейнер может обращаться к 'localhost' компьютера.

    network_mode: host

    # Ключевое слово 'depends_on' позволяет указывать, должен ли сервис,
    # прежде чем запуститься, ждать, когда будут готовы к работе другие сервисы.
    # Нам нужно, чтобы сервис 'client' дождался бы готовности к работе сервиса 'server'.
 
    depends_on:
      - server

▍5. Budowa projektu

po wejściu docker-compose.yml sporządzono wszystkie niezbędne instrukcje, projekt należy złożyć. Ten etap naszej pracy przypomina użycie polecenia docker build, ale odpowiednie polecenie jest powiązane z kilkoma usługami:

$ docker-compose build

▍6. Uruchomienie projektu

Projekt jest już gotowy, czas go uruchomić. Ten etap naszej pracy odpowiada etapowi, w którym podczas pracy z pojedynczymi kontenerami wykonywane jest polecenie docker run:

$ docker-compose up

Po wykonaniu tej komendy w terminalu powinien pojawić się tekst ładowany przez klienta z serwera: Docker-Compose is magic!.

Jak już wspomniano, serwer korzysta z portu komputera 1234 do obsługi żądań klientów. Dlatego jeśli przejdziesz pod adres w przeglądarce http://localhost:1234/, wyświetli stronę z tekstem Docker-Compose is magic!.

Przydatne polecenia

Przyjrzyjmy się niektórym poleceniom, które mogą okazać się przydatne podczas pracy z Docker Compose.

To polecenie umożliwia zatrzymanie i usunięcie kontenerów oraz innych zasobów utworzonych za pomocą polecenia docker-compose up:

$ docker-compose down

To polecenie drukuje dzienniki usług:

$ docker-compose logs -f [service name]

Przykładowo w naszym projekcie można go zastosować w następującej formie: $ docker-compose logs -f [service name].

Za pomocą tego polecenia możesz wyświetlić listę kontenerów:

$ docker-compose ps

To polecenie umożliwia wykonanie polecenia w działającym kontenerze:

$ docker-compose exec [service name] [command]

Na przykład może to wyglądać tak: docker-compose exec server ls.

Polecenie to umożliwia wyświetlenie listy obrazów:

$ docker-compose images

Wyniki

Przyjrzeliśmy się podstawom pracy z technologią Docker Compose, których znajomość pozwoli Ci korzystać z tej technologii i, w razie potrzeby, zacząć ją głębiej studiować. tutaj jest repozytorium z kodem projektu, który tutaj rozważaliśmy.

Drodzy Czytelnicy! Czy używasz Docker Compose w swoich projektach?

Źródło: www.habr.com

Przewodnik dla początkujących dotyczący Docker Compose