Udostępnij przez

Wdrażanie aplikacji Django w usłudze Azure Kubernetes Service za pomocą usługi Azure Database for PostgreSQL

W tym przewodniku szybkiego startu wdrożysz aplikację Django w klastrze usługi Azure Kubernetes Service (AKS) z użyciem elastycznego serwera Azure Database for PostgreSQL za pomocą Azure CLI.

Usługa AKS to zarządzana usługa Kubernetes używana do szybkiego wdrażania klastrów i zarządzania nimi. Serwer elastyczny usługi Azure Database for PostgreSQL to w pełni zarządzana usługa bazy danych, która zapewnia bardziej szczegółową kontrolę i elastyczność funkcji zarządzania bazami danych i ustawień konfiguracji.

Uwaga / Notatka

W tym przewodniku Szybki start założono podstawową wiedzę na temat pojęć związanych z platformą Kubernetes, Django i PostgreSQL.

Wymagania wstępne

Jeśli nie masz jeszcze konta platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

  • Uruchom usługę Azure Cloud Shell w nowym oknie przeglądarki. Możesz też zainstalować interfejs wiersza polecenia platformy Azure na komputerze lokalnym. Jeśli używasz instalacji lokalnej, zaloguj się przy użyciu polecenia az login . Aby zakończyć proces uwierzytelniania, wykonaj kroki wyświetlane na Twoim terminalu.
  • Uruchom az version, aby sprawdzić zainstalowaną wersję i biblioteki zależne. Aby zaktualizować do najnowszej wersji, uruchom az upgrade. Ten artykuł wymaga najnowszej wersji interfejsu wiersza polecenia platformy Azure. Jeśli używasz usługi Azure Cloud Shell, najnowsza wersja jest już zainstalowana.

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to grupa logiczna, w której wdrażasz zasoby platformy Azure i zarządzasz nimi. Utwórz grupę zasobów o nazwie django-project przy użyciu polecenia az-group-create w lokalizacji eastus .

az group create --name django-project --location eastus

Uwaga / Notatka

Lokalizacja grupy zasobów przechowuje metadane grupy zasobów. Jest to również miejsce, w którym zasoby są uruchamiane na platformie Azure, jeśli nie określisz innego regionu podczas tworzenia zasobów.

Następujące przykładowe dane wyjściowe przedstawiają pomyślnie utworzoną grupę zasobów:

{
  "id": "/subscriptions/<guid>/resourceGroups/django-project",
  "location": "eastus",
  "managedBy": null,

  "name": "django-project",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Tworzenie klastra AKS

Utwórz klaster AKS za pomocą polecenia az aks create. Poniższy przykład tworzy klaster o nazwie djangoappcluster z jednym węzłem. Tworzenie klastra trwa kilka minut.

az aks create --resource-group django-project --name djangoappcluster --node-count 1 --generate-ssh-keys

Po kilku minutach polecenie zostanie wykonane i zwróci informacje o klastrze w formacie JSON.

Uwaga / Notatka

Podczas tworzenia klastra usługi AKS polecenie automatycznie tworzy drugą grupę zasobów do przechowywania zasobów usługi AKS. Aby uzyskać więcej informacji, zobacz Dlaczego dwie grupy zasobów są tworzone za pomocą usługi AKS?

Połącz się z klastrem

Aby zarządzać klastrem Kubernetes, należy użyć klienta wiersza polecenia usługi Kubernetes — narzędzia kubectl. Jeśli korzystasz z usługi Azure Cloud Shell, narzędzie kubectl jest już zainstalowane.

Uwaga / Notatka

Jeśli używasz interfejsu wiersza polecenia platformy Azure lokalnie, uruchom polecenie az aks install-cli , aby zainstalować polecenie kubectl.

Aby skonfigurować narzędzie kubectl w celu nawiązania połączenia z klastrem Kubernetes, użyj polecenia az aks get-credentials. To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.

az aks get-credentials --resource-group django-project --name djangoappcluster

Aby sprawdzić połączenie z klastrem, użyj polecenia kubectl get, aby powrócić do listy węzłów klastra.

kubectl get nodes

Poniższe przykładowe dane wyjściowe zawierają jeden węzeł utworzony w poprzednich krokach. Upewnij się, że stan węzła to Gotowy:

NAME                       STATUS   ROLES   AGE     VERSION
aks-nodepool1-31718369-0   Ready    agent   6m44s   v1.12.8

Utwórz wystąpienie serwera elastycznego

Utwórz wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL za pomocą polecenia az postgreSQL flexible-server create . Następujące polecenie tworzy serwer przy użyciu wartości domyślnych i wartości usługi z lokalnego kontekstu interfejsu wiersza polecenia platformy Azure:

az postgres flexible-server create --public-access all

Serwer ma następujące atrybuty:

  • Podczas pierwszej aprowizacji serwera jest tworzona nowa pusta baza danych o nazwie postgres . W tym przewodniku szybkiego startu używana jest baza danych postgres.
  • Automatycznie wygenerowana nazwa serwera, nazwa użytkownika administratora, hasło administratora, nazwa grupy zasobów (jeśli nie została jeszcze określona w kontekście lokalnym) i ta sama lokalizacja co grupa zasobów.
  • Korzystając z argumentu dostępu publicznego, należy utworzyć serwer z dostępem publicznym dla dowolnego klienta z poprawną nazwą użytkownika i hasłem.
  • Ponieważ polecenie używa kontekstu lokalnego, tworzy serwer w grupie django-project zasobów i w regionie eastus.

Kompilowanie obrazu platformy Docker Django

Utwórz nową aplikację Django lub użyj istniejącego projektu Django. Upewnij się, że kod znajduje się w tej strukturze folderów.

└───my-djangoapp
    └───views.py
    └───models.py
    └───forms.py
    ├───templates
          . . . . . . .
    ├───static
         . . . . . . .
└───my-django-project
    └───settings.py
    └───urls.py
    └───wsgi.py
        . . . . . . .
    └─── Dockerfile
    └─── requirements.txt
    └─── manage.py

Zaktualizuj ALLOWED_HOSTS w settings.py aby upewnić się, że aplikacja Django używa zewnętrznego adresu IP przypisanego do aplikacji Kubernetes.

ALLOWED_HOSTS = ['*']

Zaktualizuj DATABASES={ } sekcję settings.py w pliku. Fragment kodu odczytuje hosta bazy danych, nazwę użytkownika i hasło z pliku manifestu Kubernetes.

DATABASES={
   'default':{
      'ENGINE':'django.db.backends.postgresql_psycopg2',
      'NAME':os.getenv('DATABASE_NAME'),
      'USER':os.getenv('DATABASE_USER'),
      'PASSWORD':os.getenv('DATABASE_PASSWORD'),
      'HOST':os.getenv('DATABASE_HOST'),
      'PORT':'5432',
      'OPTIONS': {'sslmode': 'require'}
   }
}

Generowanie pliku requirements.txt

Utwórz plik, requirements.txt aby wyświetlić listę zależności dla aplikacji Django. Oto przykładowy requirements.txt plik. Aby wygenerować plik requirements.txt dla istniejącej aplikacji, można użyć funkcji freeze > requirements.txt .

Django==2.2.17
postgres==3.0.0
psycopg2-binary==2.8.6
psycopg2-pool==1.1
pytz==2020.4

Tworzenie pliku Dockerfile

Utwórz nowy plik o nazwie Dockerfile i skopiuj poniższy fragment kodu. Ten plik Dockerfile konfiguruje środowisko Python 3.8 i instaluje wszystkie wymagania wymienione w requirements.txt pliku.

# Use the official Python image from the Docker Hub

FROM python:3.8.2

# Make a new directory to put our code in.

RUN mkdir /code

# Change the working directory.

WORKDIR /code

# Copy to code folder

COPY . /code/

# Install the requirements.

RUN pip install -r requirements.txt

# Run the application:

CMD python manage.py runserver 0.0.0.0:8000

Kompilowanie obrazu

Upewnij się, że jesteś w katalogu my-django-app w terminalu, używając polecenia cd. Uruchom następujące polecenie, aby skompilować obraz tablicy biuletynu:

docker build --tag myblog:latest .

Wdróż obraz w usłudze Docker Hub lub Azure Container Registry.

Ważne

Jeśli używasz usługi Azure Container Registry (ACR), uruchom az aks update polecenie , aby dołączyć konto usługi ACR do klastra usługi AKS.

az aks update --name djangoappcluster --resource-group django-project --attach-acr <your-acr-name>

Tworzenie pliku manifestu platformy Kubernetes

Plik manifestu Kubernetes definiuje żądany stan klastra, na przykład jakie obrazy kontenerów mają być uruchomione. Utwórz plik manifestu o nazwie djangoapp.yaml i skopiuj do niego następującą definicję YAML.

Ważne

Zaktualizuj sekcję env przy użyciu wartości SERVERNAME, YOUR-DATABASE-USERNAME i YOUR-DATABASE-PASSWORD dla elastycznego wystąpienia serwera Azure Database for PostgreSQL.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: django-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: django-app
  template:
    metadata:
      labels:
        app: django-app
    spec:
      containers:
      - name: django-app
        image: [DOCKER-HUB-USER-OR-ACR-ACCOUNT]/[YOUR-IMAGE-NAME]:[TAG]
        ports:
        - containerPort: 8000
        env:
        - name: DATABASE_HOST
          value: "SERVERNAME.postgres.database.azure.com"
        - name: DATABASE_USER
          value: "YOUR-DATABASE-USERNAME"
        - name: DATABASE_PASSWORD
          value: "YOUR-DATABASE-PASSWORD"
        - name: DATABASE_NAME
          value: "postgres"
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: "app"
                    operator: In
                    values:
                    - django-app
              topologyKey: "kubernetes.io/hostname"
---
apiVersion: v1
kind: Service
metadata:
  name: python-svc
spec:
  type: LoadBalancer
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000
  selector:
    app: django-app

Wdrażanie rozwiązania Django w klastrze usługi AKS

Wdróż aplikację przy użyciu polecenia kubectl apply . Określ nazwę manifestu YAML:

kubectl apply -f djangoapp.yaml

Następujące przykładowe dane wyjściowe przedstawiają pomyślnie utworzone wdrożenia i usługi:

deployment "django-app" created
service "python-svc" created

Wdrożenie o nazwie django-app opisuje szczegóły wdrożenia, takie jak to, których obrazów użyć do aplikacji, liczba podów i konfiguracja podów. Utworzysz usługę o nazwie python-svc , aby uwidocznić aplikację za pośrednictwem zewnętrznego adresu IP.

Testowanie aplikacji

Podczas uruchamiania aplikacji usługa Kubernetes uwidacznia fronton aplikacji w Internecie. Ten proces może potrwać kilka minut.

Aby monitorować postęp, użyj polecenia kubectl get-service z argumentem --watch.

kubectl get service python-svc --watch

Początkowo EXTERNAL-IP dla usługi django-app jest wyświetlany jako oczekujący.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
django-app   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

Gdy adres EXTERNAL-IP zmieni się z w trakcie oczekiwania na rzeczywisty publiczny adres IP, użyj CTRL-C do zatrzymania procesu monitorowania kubectl. Następujące przykładowe dane wyjściowe przedstawiają prawidłowy publiczny adres IP przypisany do usługi:

django-app  LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

Teraz otwórz przeglądarkę internetową pod zewnętrznym adresem IP usługi (http://<service-external-ip-address>) i wyświetl aplikację Django.

Uwaga / Notatka

  • Obecnie witryna Django nie korzysta z protokołu HTTPS. Aby uzyskać więcej informacji na temat protokołu HTTPS i sposobu konfigurowania routingu aplikacji dla usługi AKS, zobacz Temat Managed NGINX ingress with the application routing add-on (Zarządzana ruch przychodzący NGINX z dodatkiem routingu aplikacji).

Uruchamianie migracji bazy danych

W przypadku dowolnej aplikacji Django należy uruchomić migrację bazy danych lub zebrać pliki statyczne. Te polecenia powłoki Django można uruchomić przy użyciu polecenia $ kubectl exec <pod-name> -- [COMMAND]. Przed uruchomieniem polecenia należy znaleźć nazwę podu przy użyciu polecenia kubectl get pods.

$ kubectl get pods

Zobaczysz dane wyjściowe podobne do następujących:

NAME                             READY   STATUS          RESTARTS   AGE
django-app-5d9cd6cd8-l6x4b     1/1     Running              0       2m

Po znalezieniu nazwy zasobnika uruchom migracje bazy danych Django za pomocą polecenia $ kubectl exec <pod-name> -- [COMMAND]. /code/ jest katalogem roboczym projektu zdefiniowanego w powyższej Dockerfile sekcji.

$ kubectl exec django-app-5d9cd6cd8-l6x4b -- python /code/manage.py migrate

Dane wyjściowe wyglądają następująco:

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  . . . . . .

Jeśli wystąpią problemy, uruchom polecenie kubectl logs <pod-name> , aby zobaczyć, jaki wyjątek zgłasza aplikacja. Jeśli aplikacja działa pomyślnie, zobaczysz dane wyjściowe podobne do tych podczas uruchamiania polecenia kubectl logs.

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have 17 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
December 08, 2020 - 23:24:14
Django version 2.2.17, using settings 'django_postgres_app.settings'
Starting development server at http://0.0.0.0:8000/
Quit the server with CONTROL-C.

Czyszczenie zasobów

Aby uniknąć opłat za platformę Azure, wyczyść niepotrzebne zasoby. Gdy klaster nie jest już potrzebny, użyj polecenia az group delete , aby usunąć grupę zasobów, usługę kontenera i wszystkie powiązane zasoby.

az group delete --name django-project --yes --no-wait

Uwaga / Notatka

Po usunięciu klastra jednostka usługi Microsoft Entra używana przez klaster usługi AKS nie zostanie usunięta. Aby zapoznać się ze sposobem usunięcia jednostki usługi, zobacz uwagi dotyczące jednostki usługi AKS i jej usuwanie (AKS service principal considerations and deletion). Jeśli używasz tożsamości zarządzanej, platforma zarządza tożsamością i nie wymaga usunięcia.

Treści powiązane

  • Last updated on