Konteneryzacja aplikacji w Pythonie przy użyciu Dockera

Preslav Dobrev2023-03-07 · 5 min read

Konteneryzacja aplikacji w Pythonie przy użyciu Dockera

Docker to darmowe i otwartoźródłowe rozwiązanie do tworzenia, wdrażania i zarządzania aplikacjami w lekkiej wirtualizacji na poziomie systemu operacyjnego. W tym poradniku zademonstrujemy tworzenie aplikacji Python wewnątrz kontenera Docker.

Wymagania wstępne

Aby wykonać kroki przedstawione w tym poradniku, będziesz potrzebować następujących komponentów:

System Linux. Sprawdź configuring your own Ubuntu VPS on CloudSigma.
Zainstalowana i skonfigurowana najnowsza wersja Dockera. Dowiedz się więcej o installing Docker on Ubuntu.

Kontenery Docker

Podczas uruchamiania różnych programów w tym samym środowisku, rzeczy mogą (i będą) się psuć. Im więcej programów dodasz, tym bardziej niestabilne się ono staje. Dla przeciętnego użytkownika może to nie być wielki problem. Jednak w przypadku aplikacji o krytycznym znaczeniu dla misji, konsekwencje mogą być poważne.

Im więcej aplikacji jest wprowadzanych do systemu, tym większa jest powierzchnia ataku. Jedna przejęta aplikacja może łatwo doprowadzić do upadku całego systemu.

Aby rozwiązać te problemy, możemy użyć kontenerów Docker do piaskownicy (sandboxing) na poziomie oprogramowania:

Aplikacje wewnątrz kontenera będą miały ograniczony dostęp do plików.
Skonteneryzowane aplikacje nie mogą widzieć innych procesów uruchomionych w systemie.
Do kontenera można przydzielić określoną ilość zasobów sprzętowych.
Porty sieciowe kontenera nie są eksponowane na zewnątrz.
Spójne pakowanie niemal wszystkiego w środowiskach lokalnych i produkcyjnych.

Aby to zademonstrować, zbudujemy prosty serwer Python wewnątrz kontenera Docker, przekształcimy kontener w obraz i wdrożymy ten obraz w fikcyjnym środowisku produkcyjnym.

Step 1 – Filesystem Configuration

Aby hostować projekt, najpierw utworzymy dedykowany katalog:

mkdir -pv python-server-container/

1	mkdir -pv python-server-container/

cd !$

cd !$

Wewnątrz katalogu utwórz podkatalog src do przechowywania naszego kodu:

mkdir -pv src/

1	mkdir -pv src/

Step 2 – Building the Python Server

W tym kroku utworzymy prosty serwer HTTP w języku Python. Utwórz plik server.py:

touch server.py

1	touch server.py

Otwórz go w edytorze tekstu:

nano server.py

1	nano server.py

Wprowadź następujący kod Pythona:

from http.server import HTTPServer, SimpleHTTPRequestHandler

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
    """server entrypoint"""
    server_address = ("0.0.0.0", 8080)
    httpd = server_class(server_address, handler_class)
    print("starting server...")
    httpd.serve_forever()

if __name__ == "__main__":
    run()

from http.server import HTTPServer, SimpleHTTPRequestHandler

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):

"""server entrypoint"""

server_address = ("0.0.0.0", 8080)

httpd = server_class(server_address, handler_class)

print("starting server...")

httpd.serve_forever()

if __name__ == "__main__":

run()

Tutaj,

Używamy klasy HTTPServer i żądamy handlera ze standardowej biblioteki Pythona, co pozwala zachować prostotę programu.
Funkcja run inicjuje instancję HTTPserver.
Jak sugerują argumenty server_address, serwer będzie nasłuchiwał wszelkich połączeń przychodzących na porcie 8080.

Teraz zweryfikujemy, czy serwer działa zgodnie z oczekiwaniami. Uruchom serwer:

python3 server.py

1	python3 server.py

Z nowego terminala możemy użyć curl do wysłania żądania do serwera:

curl -iv localhost:8080

1	curl -iv localhost:8080

Alternatywnie możesz uzyskać dostęp do linku w przeglądarce internetowej:

http://localhost:8080

1	http://localhost:8080

Step 3 – Creating a Dockerfile

Plik Dockerfile zawiera instrukcje niezbędne do wygenerowania obrazu Docker. Instrukcje w pliku są wykonywane sekwencyjnie. Dowiedz się więcej o Dockerfile.

Utwórz nowy plik Dockerfile dla naszego projektu:

touch Dockerfile

1	touch Dockerfile

Now, we will introduce the necessary codes in it. Open it in a text editor:

nano Dockerfile

1	nano Dockerfile

Wprowadź następujący kod:

FROM python:latest

ENV SRC_DIR /usr/bin/src/test_server/src
COPY src/* ${SRC_DIR}/
WORKDIR ${SRC_DIR}

ENV PYTHONUNBUFFERED=1

CMD ["python", "server.py"]

FROM python:latest

ENV SRC_DIR /usr/bin/src/test_server/src

COPY src/* ${SRC_DIR}/

WORKDIR ${SRC_DIR}

ENV PYTHONUNBUFFERED=1

CMD ["python", "server.py"]

Tutaj,

Każdy Dockerfile musi zaczynać się od dyrektywy FROM . W naszym przypadku deklarujemy Pythona jako bazę obrazu Docker.
Dyrektywa ENV SRC_DIR określa lokalizację katalogu kontenera.
Dyrektywa COPY kopiuje pliki z katalogu src , który obecnie hostuje serwer Python.
Zmienna PYTHONBUFFERED=1 określa, że Python będzie wypisywać i zapisywać logi bezpośrednio do STDOUT. W przeciwnym razie logi nie byłyby wysyłane do żadnego bufora.
Dyrektywa CMD określa domyślne polecenie do uruchomienia podczas wykonywania kontenera. W tym przypadku używamy tej dyrektywy do uruchomienia naszego serwera Python.

Krok 4 – Generowanie obrazu Docker

Gdy Dockerfile jest gotowy, możemy teraz utworzyć obraz. Uruchom następujące polecenie Docker, aby rozpocząć proces:

docker build . -t python_server

1	docker build . -t python_server

Tutaj,

Flaga -t służy do oznaczenia naszego obrazu Docker jako python_server.
Docker pobierze wszystkie niezbędne komponenty i połączy je w obraz.

Krok 5 – Uruchamianie obrazu

Obraz jest gotowy do wdrożenia. Możemy go uruchomić za pomocą następującego polecenia:

docker run -p 8080:8080 python_server

1	docker run -p 8080:8080 python_server

Tutaj przekierowujemy port 8080 z lokalnej maszyny do obrazu Docker za pomocą flagi -p .

Możemy łatwo sprawdzić, czy serwer działa, używając curl:

curl -iv localhost:8080

1	curl -iv localhost:8080

Krok 6 – Zatrzymywanie serwera

W terminalu naciśnij “Ctrl + C”, aby zakończyć proces Docker:

Krok 7 – Eksportowanie i importowanie obrazu Docker

Mamy teraz funkcjonalny obraz Docker hostujący nasz serwer Python. Za pomocą funkcji eksportu i importu Docker możemy przenieść go do dowolnego innego systemu.

Najpierw sprawdź listę obrazów Docker w bieżącym systemie:

docker images

1	docker images

Naszym celem jest obraz Docker python_server , który właśnie utworzyliśmy. Poniższe polecenie wyeksportuje go jako archiwum TAR:

docker save python_server:latest > python_server.tar

1	docker save python_server:latest > python_server.tar

Po przesłaniu pliku python_server.tar na maszynę docelową, użyj następującego polecenia, aby zaimportować obraz Docker:

docker load < python_server.tar

1	docker load < python_server.tar

Podsumowanie

W tym poradniku pokazaliśmy, jak zbudować obraz Docker z aplikacji Python. Stworzyliśmy prosty serwer WWW w Pythonie i zbudowaliśmy z niego obraz Docker. Obraz Docker można teraz wdrożyć w dowolnym środowisku i oczekiwać spójnego działania.

Chcesz dowiedzieć się więcej o Dockerze? Zapoznaj się z poniższymi poradnikami:

Miłego kodowania!

Preslav Dobrev

Autor · CloudSigma

Preslav Dobrev jest projektantem kreatywnym w CloudSigma, skupiającym się na spójnej tożsamości biznesowej przy wykorzystaniu tradycyjnych i innowacyjnych kanałów marketingowych. Biegle łączy wizję artystyczną ze strategicznym marketingiem, tworząc wywierające wpływ narracje marki.

Konteneryzacja aplikacji w Pythonie przy użyciu Dockera

Wymagania wstępne

Kontenery Docker

Step 1 – Filesystem Configuration

Step 2 – Building the Python Server

Step 3 – Creating a Dockerfile

Krok 4 – Generowanie obrazu Docker

Krok 5 – Uruchamianie obrazu

Krok 6 – Zatrzymywanie serwera

Krok 7 – Eksportowanie i importowanie obrazu Docker

Podsumowanie

Preslav Dobrev

Komentarze