Docker Compose Python MongoDB – jak połączyć te trzy technologie?

Świat technologii rozwija się w zawrotnym tempie, a jednym z narzędzi, które zyskuje na popularności, jest Docker. Pozwala on na tworzenie kontenerów, które pomagają w zarządzaniu aplikacjami i ich zależnościami. Z kolei MongoDB, popularna baza danych NoSQL, staje się standardem w wielu projektach. Co się stanie, gdy połączymy te trzy technologie – Docker, Python i MongoDB? Odpowiedź jest prosta – powstaje niesamowite, elastyczne środowisko do budowania aplikacji!

Co to jest Docker Compose?

Docker Compose to narzędzie, które pozwala na łatwe definiowanie i uruchamianie wielokontenerowych aplikacji w Dockerze. Dzięki plikowi konfiguracyjnemu YAML, Docker Compose pozwala na jednoczesne zarządzanie wieloma kontenerami, co sprawia, że proces uruchamiania aplikacji staje się prostszy i bardziej przejrzysty.

W przypadku aplikacji wykorzystujących kilka technologii, takich jak Python i MongoDB, Docker Compose staje się niezwykle przydatnym narzędziem. Dzięki niemu możemy zdefiniować zarówno aplikację napisaną w Pythonie, jak i bazę danych MongoDB, a wszystko to w jednym pliku konfiguracyjnym. Docker Compose dba o to, by uruchomienie naszej aplikacji nie wymagało ręcznego uruchamiania każdego z kontenerów.

Dlaczego warto używać Docker Compose z Pythonem i MongoDB?

Łączenie Docker Compose z Pythonem i MongoDB daje nam wiele korzyści. Przede wszystkim:

• Izolacja środowiska – Docker pozwala na uruchomienie aplikacji w izolowanych kontenerach, co sprawia, że każda część aplikacji jest od siebie niezależna.
• Prosta konfiguracja – Dzięki Docker Compose możemy łatwo skonfigurować zarówno naszą aplikację, jak i bazę danych, w jednym miejscu.
• Skalowalność – Docker pozwala na łatwe skalowanie aplikacji, co w przyszłości może okazać się bardzo przydatne, gdy nasza aplikacja zacznie rosnąć.
• Łatwość w utrzymaniu – Dzięki kontenerom można łatwo utrzymywać różne wersje aplikacji w jednym systemie, bez konieczności instalowania ich na maszynie lokalnej.

Jak zbudować środowisko Docker Compose z Pythonem i MongoDB?

Skoro już wiemy, dlaczego warto używać Docker Compose w połączeniu z Pythonem i MongoDB, czas na konkretne kroki. W tym przykładzie stworzymy aplikację w Pythonie, która będzie komunikować się z MongoDB za pomocą odpowiedniego sterownika i uruchomimy ją w środowisku Docker Compose. Oto kroki, które należy wykonać:

Krok 1: Stwórzmy projekt

Zaczynamy od stworzenia folderu, w którym umieścimy nasz projekt. W tym folderze będziemy przechowywać pliki konfiguracyjne oraz skrypty Pythona. W terminalu wpiszmy:

mkdir docker-python-mongodb
cd docker-python-mongodb

Krok 2: Plik Dockerfile dla aplikacji w Pythonie

Dockerfile to plik, który zawiera instrukcje, jak zbudować obraz Docker dla naszej aplikacji. W naszym przypadku chcemy, aby Docker wykonał następujące kroki:

• Użyj obrazu Pythona jako podstawowego obrazu.
• Zainstaluj zależności aplikacji, takie jak biblioteka do pracy z MongoDB (np. pymongo).
• Skopiuj pliki aplikacji do obrazu.
• Uruchom naszą aplikację.

W katalogu projektu tworzymy plik Dockerfile z następującą zawartością:

FROM python:3.9

# Ustawienie katalogu roboczego
WORKDIR /app

# Kopiowanie pliku z wymaganiami
COPY requirements.txt .

# Instalowanie zależności
RUN pip install --no-cache-dir -r requirements.txt

# Kopiowanie kodu aplikacji
COPY . .

# Uruchomienie aplikacji
CMD ["python", "app.py"]

Oczywiście musimy również stworzyć plik requirements.txt, który będzie zawierał wszystkie wymagane biblioteki:

pymongo
flask

Krok 3: Tworzymy aplikację w Pythonie

Następnie tworzymy plik aplikacji app.py, w którym będziemy łączyć się z MongoDB i wykonywać proste operacje, takie jak zapis i odczyt danych. Aplikacja będzie działała na frameworku Flask, który umożliwi nam szybkie uruchomienie serwera:

from flask import Flask
from pymongo import MongoClient

app = Flask(__name__)

# Konfiguracja połączenia z MongoDB
client = MongoClient("mongodb://mongo:27017/")
db = client["mydatabase"]
collection = db["mycollection"]

@app.route('/')
def hello_world():
    collection.insert_one({"name": "John", "age": 30})
    return "Dane zostały zapisane do bazy danych MongoDB!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

W tym kodzie używamy Flask do stworzenia prostej aplikacji, która zapisuje dane do bazy danych MongoDB. MongoDB jest uruchamiane w kontenerze o nazwie "mongo", dlatego w adresie URL łączymy się z bazą danych poprzez nazwę kontenera.

Krok 4: Plik konfiguracyjny Docker Compose

Teraz czas na plik konfiguracyjny docker-compose.yml, który będzie zawierał wszystkie niezbędne informacje dotyczące kontenerów. Tworzymy ten plik w katalogu projektu:

version: '3'
services:
  mongo:
    image: mongo:latest
    volumes:
      - mongo-data:/data/db
    networks:
      - app-network

  python-app:
    build: .
    volumes:
      - .:/app
    ports:
      - "5000:5000"
    networks:
      - app-network
    depends_on:
      - mongo

volumes:
  mongo-data:

networks:
  app-network:

W tym pliku definiujemy dwa kontenery:

• mongo – kontener MongoDB, który będzie przechowywał dane w woluminie.
• python-app – kontener z naszą aplikacją w Pythonie, który łączy się z MongoDB i uruchamia serwer Flask.

Jak uruchomić projekt?

Aby uruchomić projekt, wystarczy wpisać w terminalu poniższą komendę w katalogu, w którym znajduje się plik docker-compose.yml:

docker-compose up

Po uruchomieniu aplikacji, kontener MongoDB oraz kontener z aplikacją Python zostaną uruchomione. Aplikacja będzie dostępna pod adresem http://localhost:5000. Po wejściu na ten adres dane zostaną zapisane do bazy MongoDB, a w odpowiedzi zobaczymy komunikat, że dane zostały zapisane.

Podsumowanie

Docker Compose, Python i MongoDB to świetne połączenie, które umożliwia tworzenie elastycznych i skalowalnych aplikacji. Dzięki Dockerowi możemy łatwo zarządzać wszystkimi kontenerami i zależnościami w jednym pliku konfiguracyjnym. Połączenie tego narzędzia z Pythonem i MongoDB pozwala na szybkie prototypowanie aplikacji, które mogą w przyszłości zostać rozwinięte i skalowane. Mam nadzieję, że ten artykuł pomógł Ci zrozumieć, jak połączyć te technologie w jednym projekcie!