Delen via

Zelfstudie: Django-app implementeren in AKS met Azure Database for PostgreSQL - Flexible Server

  • Artikel

VAN TOEPASSING OP: Azure Database for PostgreSQL - Flexibele server

In deze quickstart implementeert u een Django-toepassing in een AKS-cluster (Azure Kubernetes Service) met flexibele Azure Database for PostgreSQL-server met behulp van de Azure CLI.

AKS is een beheerde Kubernetes-service waarmee u snel clusters kunt implementeren en beheren. Azure Database for PostgreSQL flexibele server is een volledig beheerde databaseservice die is ontworpen om gedetailleerdere controle en flexibiliteit te bieden voor databasebeheerfuncties en configuratie-instellingen.

Notitie

In deze quickstart wordt ervan uitgegaan dat u basiskennis hebt van Kubernetes-concepten, Django en PostgreSQL.

Vereisten

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

  • Start Azure Cloud Shell in een nieuw browservenster. U kunt Azure CLI ook installeren op uw lokale computer. Als u een lokale installatie gebruikt, meldt u zich aan met Azure CLI met behulp van de opdracht az login . Volg de stappen die worden weergegeven in de terminal, om het verificatieproces te voltooien.
  • Voer az version uit om de geïnstalleerde versie en afhankelijke bibliotheken te vinden. Voer az upgrade uit om te upgraden naar de nieuwste versie. Voor dit artikel is de nieuwste versie van de Azure CLI vereist. Als u Azure Cloud Shell gebruikt, is de nieuwste versie al geïnstalleerd.

Een brongroep maken

Een Azure-resourcegroep is een logische groep waarin Azure-resources worden geïmplementeerd en beheerd. We gaan een resourcegroep maken, django-project met behulp van de opdracht az-group-create op de locatie eastus. 

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

Notitie

De locatie voor de resourcegroep is de plaats waar de metagegevens van de resourcegroep worden opgeslagen. Dit is ook de locatie waar uw resources worden uitgevoerd in Azure als u tijdens het maken van de resource geen andere regio opgeeft.

In de volgende voorbeelduitvoer ziet u dat de resourcegroep is gemaakt:

{
  "id": "/subscriptions/<guid>/resourceGroups/django-project",
  "location": "eastus",
  "managedBy": null,
  
  "name": "django-project",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Een AKS-cluster maken

Gebruik de opdracht az aks create om een AKS-cluster te maken. In het volgende voorbeeld wordt een cluster met de naam djangoappcluster gemaakt met één knooppunt. Dit zal enkele minuten in beslag nemen.

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

Na enkele minuten is de opdracht voltooid en retourneert deze informatie over het cluster in JSON-indeling.

Notitie

Wanneer een AKS-cluster wordt gemaakt, wordt automatisch een tweede resourcegroep gemaakt om de AKS-resources in op te slaan. Zie Waarom worden er twee resourcegroepen gemaakt met AKS?

Verbinding maken met het cluster

Als u een Kubernetes-cluster wilt beheren, gebruikt u kubectl, de Kubernetes-opdrachtregelclient. Als u Azure Cloud Shell gebruikt, is kubectl al geïnstalleerd.

Notitie

Als u Azure CLI lokaal uitvoert, voert u de opdracht az aks install-cli uit om te installeren kubectl.

Gebruik de opdracht az aks get-credentials om kubectl zodanig te configureren dat er verbinding wordt gemaakt met het Kubernetes-cluster. Bij deze opdracht worden referenties gedownload en wordt Kubernetes CLI geconfigureerd voor het gebruik van deze referenties.

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

Als u de verbinding met uw cluster wilt controleren, gebruikt u de opdracht kubectl get om een lijst met clusterknooppunten te retourneren.

kubectl get nodes

In de volgende voorbeelduitvoer ziet u het enkele knooppunt dat is gemaakt in de vorige stappen. Zorg ervoor dat de status van het knooppunt Ready is:

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

Een exemplaar van een flexibele Azure Database for PostgreSQL-server maken

Maak een exemplaar van een flexibele Azure Database for PostgreSQL-server met de opdracht az postgreSQL flexible-server create . Met de volgende opdracht maakt u een server met de standaardinstellingen van de service en waarden van de lokale context van uw Azure CLI:

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

De gemaakte server heeft de volgende kenmerken:

  • Er wordt een nieuwe, lege database, postgres, gemaakt wanneer de server voor het eerst wordt ingericht. In deze quickstart gebruiken we deze database.
  • Automatisch gegenereerde servernaam, gebruikersnaam van beheerder, beheerderswachtwoord, resourcegroepnaam (indien nog niet opgegeven in lokale context) en op dezelfde locatie als uw resourcegroep.
  • Met behulp van een argument voor openbare toegang kunt u een server maken met openbare toegang tot elke client met de juiste gebruikersnaam en het juiste wachtwoord.
  • Omdat de opdracht gebruikmaakt van lokale context, wordt de server in de resourcegroep django-project en in de regio eastusgemaakt.

Een Django Docker-installatiekopie bouwen

Maak een nieuwe Django-toepassing of gebruik uw bestaande Django-project. Zorg ervoor dat de code deze mapstructuur heeft.

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

Werk ALLOWED_HOSTS in settings.py bij om ervoor te zorgen dat de Django-toepassing gebruikmaakt van het externe IP-adres dat wordt toegewezen aan de Kubernetes-app.

ALLOWED_HOSTS = ['*']

Sectie bijwerken DATABASES={ } in het settings.py bestand. Het onderstaande codefragment leest de databasehost, gebruikersnaam en wachtwoord uit het Kubernetes-manifestbestand.

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'}
   }
}

Een requirements.txt-bestand genereren

Maak een requirements.txt-bestand om de afhankelijkheden voor de Django-toepassing in te vermelden. Hier volgt een voorbeeldbestand requirements.txt . U kunt pip freeze > requirements.txt gebruiken om een requirements.txt-bestand voor uw bestaande toepassing te genereren.

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

Een Dockerfile maken

Maak een nieuw bestand met de naam Dockerfile, en kopieer het onderstaande codefragment. Met dit Dockerfile wordt Python 3.8 ingesteld en worden alle vereisten geïnstalleerd die zijn vermeld in het requirements.txt-bestand.

# 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

Uw installatiekopie bouwen

Zorg ervoor dat u zich in de map my-django-app in een terminal bevindt met behulp van de opdracht cd. Voer de volgende opdracht uit om de installatiekopie van het bulletinboard te bouwen:

docker build --tag myblog:latest .

Implementeer uw installatiekopie op de Docker-hub of het Azure-containerregister.

Belangrijk

Als u Azure Container Registry (ACR) gebruikt, voert u de az aks update opdracht uit om een ACR-account te koppelen aan het AKS-cluster.

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

Kubernetes-manifestbestand maken

In een Kubernetes-manifestbestand wordt een gewenste status voor het cluster gedefinieerd, zoals welke containerinstallatiekopieën moeten worden uitgevoerd. Maak een manifestbestand met de naam djangoapp.yaml en kopieer er de volgende YAML-definitie in.

Belangrijk

Sectie env hieronder bijwerken met uw SERVERNAME, YOUR-DATABASE-USERNAMEvan YOUR-DATABASE-PASSWORD uw exemplaar van flexibele Azure Database for PostgreSQL-server.

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

Django implementeren op het AKS-cluster

Implementeer de toepassing met de opdracht kubectl apply en geef de naam op van uw YAML-manifest:

kubectl apply -f djangoapp.yaml

In de volgende voorbeelduitvoer ziet u dat je implementaties en services zijn gemaakt:

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

Met een implementatie django-app kunt u details van uw implementatie beschrijven, zoals welke installatiekopieën voor de app moeten worden gebruikt, het aantal pods en podconfiguratie. Er wordt een service python-svc gemaakt om de toepassing beschikbaar te maken via een extern IP-adres.

De toepassing testen

Wanneer de toepassing wordt uitgevoerd, maakt een Kubernetes-service de front-end van de toepassing beschikbaar op internet. Dit proces kan enkele minuten duren.

Gebruik de opdracht kubectl get service met het argument --watch om de voortgang te controleren.

kubectl get service python-svc --watch

Eerst wordt EXTERNAL-IP voor de service django-app weergegeven als In behandeling.

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

Zodra het EXTERNAL-IP-adres is gewijzigd van in behandeling in een echt openbaar IP-adres, gebruikt u CTRL-C om het controleproces van kubectl te stoppen. In de volgende voorbeelduitvoer ziet u een geldig openbaar IP-adres dat aan de service is toegewezen:

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

Open nu een webbrowser naar het externe IP-adres van uw service (http://<service-external-ip-address>) en bekijk de Django-toepassing.

Notitie

Databasemigraties uitvoeren

Voor elke Django-toepassing moet u databasemigratie uitvoeren of statische bestanden verzamelen. U kunt deze Django Shell-opdrachten uitvoeren met behulp van $ kubectl exec <pod-name> -- [COMMAND]. Voordat u de opdracht uitvoert, moet u de podnaam vinden met behulp van kubectl get pods.

$ kubectl get pods

U ziet een uitvoer zoals deze:

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

Zodra de podnaam is gevonden, kunt u Django-databasemigraties uitvoeren met behulp van de opdracht $ kubectl exec <pod-name> -- [COMMAND]. Opmerking: /code/ is de werkmap voor het project dat hierboven in Dockerfile is gedefinieerd.

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

De uitvoer ziet er ongeveer als volgt uit

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
  . . . . . .

Als u problemen ondervindt, voert u uit kubectl logs <pod-name> om te zien welke uitzondering wordt gegenereerd door uw toepassing. Als de toepassing goed werkt, ziet u uitvoer die er ongeveer zo uitziet als u kubectl logs uitvoert.

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.

De resources opschonen

Om Azure-kosten te vermijden, moet u overbodige resources opschonen. Gebruik de opdracht az group delete om de resourcegroep, de containerservice en alle gerelateerde resources te verwijderen wanneer u het cluster niet meer nodig hebt.

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

Notitie

Wanneer u het cluster verwijdert, wordt de Microsoft Entra-service-principal die door het AKS-cluster wordt gebruikt, niet verwijderd. Zie Overwegingen voor en verwijdering van AKS service-principal voor stappen voor het verwijderen van de service-principal. Als u een beheerde identiteit hebt gebruikt, wordt de identiteit beheerd door het platform en hoeft deze niet te worden verwijderd.

Volgende stappen