Jak automatycznie tworzyć i konfigurować niestandardowe obrazy platformy Docker za pomocą pliku Dockerfile — część 3

W tym samouczku skupimy się na tworzeniu niestandardowego obrazu Dockera w oparciu o Ubuntu z zainstalowaną usługą Apache. Cały proces zostanie zautomatyzowany przy użyciu pliku Dockerfile.

Obrazy Dockera można automatycznie tworzyć z plików tekstowych o nazwie Dockerfiles. Plik Dockera zawiera uporządkowane instrukcje lub polecenia krok po kroku używane do tworzenia i konfigurowania obrazu Dockera.

Wymagania

• Zainstaluj Docker i naucz się manipulować kontenerem Docker – część 1
• Wdrażanie i uruchamianie aplikacji w kontenerach Docker — część 2

Zasadniczo plik Dockera zawiera różne instrukcje umożliwiające zbudowanie i skonfigurowanie określonego kontenera w oparciu o Twoje wymagania. Najczęściej stosowane są następujące instrukcje, a niektóre z nich są obowiązkowe:

1. FROM=Obowiązkowe jako pierwsza instrukcja w pliku Dockera. Instruuje Dockera, aby pobrał obraz podstawowy, z którego budujesz nowy obraz. Użyj tagu, aby określić dokładny obraz, z którego budujesz:

Ex: FROM ubuntu:20.04

1. MAINTAINER=Autor obrazu kompilacji
2. RUN=Tej instrukcji można użyć w wielu wierszach i uruchamia ona dowolne polecenia po utworzeniu obrazu Dockera.
3. CMD=Uruchom dowolne polecenie po uruchomieniu obrazu Dockera. Użyj tylko jednej instrukcji CMD w pliku Dockerfile.
4. ENTRYPOINT=To samo co CMD, ale używane jako główne polecenie dla obrazu.
5. EXPOSE=Nakazuje kontenerowi nasłuchiwanie na portach sieciowych podczas działania. Domyślnie porty kontenerów nie są dostępne z hosta.
6. ENV=Ustaw zmienne środowiskowe kontenera.
7. ADD=Skopiuj zasoby (pliki, katalogi lub pliki z adresów URL).

Krok 1: Tworzenie lub zapisywanie repozytorium plików Dockerfile

1. Najpierw utwórzmy pewnego rodzaju repozytoria Dockerfile, aby w przyszłości ponownie wykorzystać pliki do tworzenia innych obrazów. Utwórz pusty katalog gdzieś na partycji /var, w którym utworzymy plik z instrukcjami, które zostaną użyte do zbudowania nowego obrazu Dockera.

mkdir -p /var/docker/ubuntu/apache
touch /var/docker/ubuntu/apache/Dockerfile

2. Następnie rozpocznij edycję pliku, postępując zgodnie z poniższymi instrukcjami:

vi /var/docker/ubuntu/apache/Dockerfile

Fragment pliku Dokerfile:

FROM ubuntu
MAINTAINER  your_name  <[email >
RUN apt-get -y install apache2
RUN echo “Hello Apache server on Ubuntu Docker” > /var/www/html/index.html
EXPOSE 80
CMD /usr/sbin/apache2ctl -D FOREGROUND

Przejdźmy teraz do instrukcji dotyczących plików:

Pierwsza linia mówi nam, że budujemy na podstawie obrazu Ubuntu. Jeśli nie przesłano żadnego tagu, powiedzmy na przykład 14:10, zostanie użyty najnowszy obraz z Docker Hub.

W drugiej linii dodaliśmy imię i nazwisko oraz adres e-mail twórcy obrazu. Następne dwie linie RUN zostaną wykonane w kontenerze podczas budowania obrazu i zainstalują demona Apache oraz echo jakiś tekst na domyślnej stronie internetowej Apache .

Linia EXPOSE poinstruuje kontener Docker, aby nasłuchiwał na porcie 80, ale port nie będzie dostępny z zewnątrz. Ostatnia linia instruuje kontener, aby po uruchomieniu kontenera uruchomił usługę Apache na pierwszym planie.

3. Ostatnią rzeczą, którą musimy zrobić, to rozpocząć tworzenie obrazu, wydając poniższe polecenie, które lokalnie utworzy nowy obraz Dockera o nazwie ubuntu-apache w oparciu o Dockerfile utworzony wcześniej, jak pokazano w tym przykładzie:

docker build -t ubuntu-apache /var/docker/ubuntu/apache/

4. Po utworzeniu obrazu w Dockerze możesz wyświetlić listę wszystkich dostępnych obrazów i zidentyfikować swój obraz, wydając następujące polecenie:

docker images

Krok 2: Uruchom kontener i uzyskaj dostęp do Apache z sieci LAN

5. Aby kontener mógł działać w sposób ciągły (w tle) i uzyskać dostęp do usług (portów) dostępnych w kontenerze z hosta lub innej zdalnej maszyny w sieci LAN, uruchom poniższe polecenie w wierszu terminala hosta :

docker run -d -p 81:80 ubuntu-apache

Tutaj opcja -d uruchamia kontener ubuntu-apache w tle (jako demon), a opcja -p odwzorowuje port kontenera 80 do portu lokalnego hosta 81. Dostęp do usługi Apache poza siecią LAN można uzyskać wyłącznie przez port 81.

Polecenie Netstat da ci wyobrażenie o tym, na jakich portach nasłuchuje host.

Po uruchomieniu kontenera możesz także uruchomić komendę docker ps, aby wyświetlić status działającego kontenera.

6. Stronę internetową można wyświetlić na hoście z wiersza poleceń za pomocą narzędzia curl w odniesieniu do adresu IP komputera, hosta lokalnego lub interfejsu sieciowego dokera na porcie 81. Użyj polecenia IP wiersz pokazujący adresy IP interfejsów sieciowych.

ip addr               [List nework interfaces]
curl ip-address:81    [System Docker IP Address]
curl localhost:81     [Localhost]

7. Aby odwiedzić stronę kontenera ze swojej sieci, otwórz przeglądarkę w zdalnej lokalizacji i użyj protokołu HTTP, adresu IP maszyny, na której działa kontener, a następnie portu 81, jak pokazano na poniżej obrazu.

http://ip-address:81

8. Aby dowiedzieć się, jakie procesy działają w kontenerze, wydaj następującą komendę:

docker ps
docker top <name or ID of the container>

9. Aby zatrzymać kontener, wydaj polecenie docker stop, po którym należy podać identyfikator lub nazwę kontenera.

docker stop <name or ID of the container>
docker ps

10. Jeśli chcesz przypisać opisową nazwę kontenerowi, użyj opcji --name, jak pokazano w poniższym przykładzie:

docker run --name my-www -d -p 81:80 ubuntu-apache
docker ps

Teraz możesz odwoływać się do kontenera w celu manipulacji (start, stop, góra, statystyki itp.) tylko przy użyciu przypisanej mu nazwy.

docker stats my-www

Krok 3: Utwórz ogólnosystemowy plik konfiguracyjny dla kontenera Docker

11. W CentOS/RHEL możesz utworzyć plik konfiguracyjny systemd i zarządzać kontenerem tak, jak zwykle robisz to w przypadku każdej innej usługi lokalnej.

Na przykład utwórz nowy plik systemowy o nazwie, powiedzmy, apache-docker.service, używając następującego polecenia:

vi /etc/systemd/system/apache-docker.service

fragment pliku apache-docker.service:

[Unit]
Description=apache container
Requires=docker.service
After=docker.service

[Service]
Restart=always
ExecStart=/usr/bin/docker start -a my-www
ExecStop=/usr/bin/docker stop -t 2 my-www

[Install]
WantedBy=local.target

12. Po zakończeniu edycji pliku zamknij go, załaduj ponownie demona systemowego, aby odzwierciedlić zmiany i uruchom kontener, wydając następujące polecenia:

systemctl daemon-reload
systemctl start apache-docker.service
systemctl status apache-docker.service

To był tylko prosty przykład tego, co można zrobić za pomocą prostego pliku Dockerfile, ale można wstępnie zbudować kilka dość zaawansowanych aplikacji, które można uruchomić w ciągu kilku sekund przy minimalnych zasobach i wysiłku.

Dalsza lektura: