Compartir a través de

Implementación de una aplicación de Django en Azure Kubernetes Service con Azure Database for PostgreSQL

En este inicio rápido, implementará una aplicación de Django en un clúster de Azure Kubernetes Service (AKS) con el servidor flexible de Azure Database for PostgreSQL mediante la CLI de Azure.

AKS es un servicio de Kubernetes administrado que se usa para implementar y administrar clústeres rápidamente. Servidor flexible de Azure Database for PostgreSQL es un servicio de base de datos totalmente administrado diseñado para dar un control más exhaustivo y una mayor flexibilidad sobre las funciones de administración de bases de datos y las opciones de configuración.

Nota:

En este inicio rápido se presupone un conocimiento básico de los conceptos de Kubernetes, Django y PostgreSQL.

Prerrequisitos

Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.

  • Inicie Azure Cloud Shell en una nueva ventana del explorador. También puede instalar la CLI de Azure en la máquina local. Si usa una instalación local, inicie sesión con el comando az login . Siga los pasos que se muestran en el terminal para completar el proceso de autenticación.
  • Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade. En este artículo se necesita la versión más reciente de la CLI de Azure. Si usa Azure Cloud Shell, ya está instalada la versión más reciente.

Creación de un grupo de recursos

Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran recursos de Azure. Cree un grupo de recursos denominado django-project mediante el comando az-group-create en la ubicación eastus .

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

Nota:

La ubicación del grupo de recursos almacena los metadatos del grupo de recursos. También es donde se ejecutan los recursos en Azure si no especifica otra región durante la creación de recursos.

En la siguiente salida de ejemplo se muestra que los recursos se crearon correctamente:

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

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

Creación de un clúster de AKS

Use el comando az aks create para crear un clúster de AKS. En el siguiente ejemplo, se crea un clúster llamado djangoappcluster con un nodo. Para crear el clúster, se necesitan varios minutos.

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

Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Nota:

Al crear un clúster de AKS, el comando crea automáticamente un segundo grupo de recursos para almacenar los recursos de AKS. Para más información, consulte ¿Por qué se crean dos grupos de recursos con AKS?

Conectarse al clúster

Para administrar un clúster de Kubernetes, use kubectl, el cliente de línea de comandos de Kubernetes. Si usa Azure Cloud Shell, kubectl ya está instalado.

Nota:

Si ejecuta la CLI de Azure localmente, ejecute el comando az aks install-cli para instalar kubectl.

Para configurar kubectl para conectarse a su clúster de Kubernetes, use el comando az aks get-credentials. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.

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

Para comprobar la conexión al clúster, use el comando kubectl get para devolver una lista de los nodos del clúster.

kubectl get nodes

La salida del ejemplo siguiente muestra el nodo único creado en los pasos anteriores. Asegúrese de que el estado del nodo es Listo:

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

Creación de una instancia de servidor flexible

Cree una instancia de servidor flexible de Azure Database for PostgreSQL con el comando az postgreSQL flexible-server create. El siguiente comando crea un servidor con los valores predeterminados de servicio y los valores del contexto local de la CLI de Azure:

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

El servidor tiene los siguientes atributos:

  • Se crea una nueva base de datos vacía denominada postgres cuando el servidor se aprovisiona por primera vez. En este inicio rápido se usa la postgres base de datos.
  • Nombre del servidor generado automáticamente, nombre de usuario de administrador, contraseña de administrador, nombre del grupo de recursos (si aún no lo especificó en el contexto local) y la misma ubicación que el grupo de recursos.
  • Mediante el argumento de acceso público, se crea un servidor con acceso público para cualquier cliente con el nombre de usuario y la contraseña correctos.
  • Dado que el comando usa el contexto local, crea el servidor en el grupo django-project de recursos y en la región eastus.

Compilación de la imagen de Docker de Django

Cree una aplicación Django o use el proyecto Django existente. Asegúrese de que el código se encuentra en esta estructura de carpetas.

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

Actualice ALLOWED_HOSTS en settings.py para asegurarse de que la aplicación Django usa la dirección IP externa que se asigna a la aplicación de Kubernetes.

ALLOWED_HOSTS = ['*']

Actualice la sección DATABASES={ } del archivo settings.py. El fragmento de código lee el host de base de datos, el nombre de usuario y la contraseña del archivo de manifiesto de 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'}
   }
}

Generación de un archivo requirements.txt

Cree un requirements.txt archivo para enumerar las dependencias de la aplicación Django. Este es un archivo requirements.txt de ejemplo. Puede usar pip freeze > requirements.txt para generar un archivo requirements.txt para la aplicación existente.

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

Creación de un archivo Dockerfile

Cree un nuevo archivo denominado Dockerfile y copie el siguiente fragmento de código. Este Dockerfile configura Python 3.8 e instala todos los requisitos enumerados en el requirements.txt archivo.

# 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

Compilación de la imagen

Asegúrese de que está en el my-django-app directorio de un terminal mediante el cd comando . Ejecute el siguiente comando para compilar la imagen del tablón de anuncios:

docker build --tag myblog:latest .

Inserte la imagen en Docker hub o Azure Container Registry.

Importante

Si usa Azure Container Registry (ACR), ejecute el az aks update comando para adjuntar la cuenta de ACR al clúster de AKS.

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

Creación del archivo de manifiesto de Kubernetes

Un archivo de manifiesto de Kubernetes define un estado deseado del clúster, por ejemplo, qué imágenes de contenedor se van a ejecutar. Cree un archivo de manifiesto denominado djangoapp.yaml y copie en la siguiente definición de YAML.

Importante

Actualice la sección env con los valores SERVERNAME, YOUR-DATABASE-USERNAME y YOUR-DATABASE-PASSWORD para su instancia de servidor flexible de Azure Database para 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

Implementación de Django en un clúster de AKS

Implemente la aplicación mediante el comando kubectl apply . Especifique el nombre del manifiesto de YAML:

kubectl apply -f djangoapp.yaml

En la salida de ejemplo siguiente se muestran las implementaciones y los servicios creados correctamente:

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

Una implementación denominada django-app describe los detalles de la implementación, como las imágenes que se usarán para la aplicación, el número de pods y la configuración del pod. Cree un servicio denominado python-svc para exponer la aplicación a través de una dirección IP externa.

Prueba de la aplicación

Cuando se ejecuta la aplicación, un servicio de Kubernetes expone el front-end de la aplicación a Internet. Este proceso puede tardar unos minutos en completarse.

Para supervisar el progreso, utilice el comando kubectl get service con el argumento --watch.

kubectl get service python-svc --watch

Inicialmente, el EXTERNAL-IP del servicio django-app se muestra como pendiente.

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

Cuando la dirección EXTERNAL-IP cambie de pendiente a una dirección IP pública real, use CTRL-C para detener el proceso de inspección de kubectl. En la salida del ejemplo siguiente se muestra una dirección IP pública válida asignada al servicio:

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

Ahora, abra un explorador web en la dirección IP externa del servicio (http://<service-external-ip-address>) y vea la aplicación de Django.

Nota:

Ejecución de migraciones de base de datos

Para cualquier aplicación de Django, debe ejecutar una migración de base de datos o recopilar archivos estáticos. Puede ejecutar estos comandos de shell de Django mediante $ kubectl exec <pod-name> -- [COMMAND]. Antes de ejecutar el comando, debe buscar el nombre del pod mediante kubectl get pods.

$ kubectl get pods

Verá una salida similar a la siguiente:

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

Una vez que encuentre el nombre del pod, ejecute migraciones de base de datos de Django con el comando $ kubectl exec <pod-name> -- [COMMAND]. /code/ es el directorio de trabajo del proyecto definido en la Dockerfile sección anterior.

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

El resultado tendrá una apariencia similar a la siguiente:

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

Si tiene problemas, ejecute kubectl logs <pod-name> para ver qué excepción produce la aplicación. Si la aplicación funciona correctamente, verá una salida como esta al ejecutar 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.

Limpiar los recursos

Para evitar cargos de Azure, limpie los recursos innecesarios. Cuando ya no necesite el clúster, use el comando az group delete para quitar el grupo de recursos, el servicio de contenedor y todos los recursos relacionados.

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

Nota:

Cuando elimina el clúster, la entidad de servicio de Microsoft Entra que utiliza el clúster de AKS no se quita. Para conocer los pasos que hay que realizar para quitar la entidad de servicio, consulte Consideraciones principales y eliminación de AKS. Si usa una identidad administrada, la plataforma administra la identidad y no requiere la eliminación.

Contenido relacionado

  • Last updated on