Ejecuta Django en Google Kubernetes Engine

Las apps de Django que se ejecutan en GKE escalan dinámicamente según el tráfico.

En este instructivo, se da por sentado que tienes conocimientos de desarrollo web con Django. Si es la primera vez que desarrollas con Django, es recomendable que escribas tu primera app de Django antes de continuar.

Si bien en este instructivo se muestra Django de forma específica, puedes usar este proceso de implementación con otros marcos de trabajo basados en Django, como Wagtail y el Django CMS.

En este instructivo, se usa Django 5, que requiere al menos Python 3.10.

También necesitas tener Docker instalado.

Objetivos

En este instructivo, podrás:

Crear y conectar una base de datos de Cloud SQL
Crea y usa valores de secretos de Kubernetes.
Implementa una app de Django en Google Kubernetes Engine.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios nuevos de Google Cloud cumplan con los requisitos para acceder a una prueba gratuita.

Antes de comenzar

Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Instala la CLI de gcloud.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Instala la CLI de gcloud.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Prepara el entorno

Clona una app de ejemplo

El código de la app de muestra de Django está en el repositorio GoogleCloudPlatform/python-docs-samples en GitHub.

Puedes descargar la muestra como un archivo ZIP y extraerla o clonar el repositorio en tu máquina local:
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```

Ve al directorio que contiene el código de muestra:

Linux/macOS

cd python-docs-samples/kubernetes_engine/django_tutorial

Windows

cd python-docs-samples\kubernetes_engine\django_tutorial

Confirma tu configuración de Python

En este instructivo, se usa Python para ejecutar la aplicación de ejemplo en tu máquina. El código de ejemplo también requiere la instalación de dependencias.

Para obtener más detalles, consulta la guía del entorno de desarrollo de Python.

Confirma que tu versión de Python sea al menos la 3.10.
```
 python -V
```
Deberías ver Python 3.10.0 o una versión posterior.

Nota: Si ves un número de versión que comienza con "2", es posible que debas ejecutar python3 en lugar de python. Si es así, recuerda hacer referencia a la instalación de Python que elegiste cuando ejecutes comandos de python.

Crea un entorno virtual de Python y, luego, instala las dependencias:

Linux/macOS

python -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

Windows

python -m venv venv
venv\scripts\activate
pip install --upgrade pip
pip install -r requirements.txt

Descarga el proxy de Cloud SQL Auth para conectarte a Cloud SQL desde tu máquina local

Cuando se implementa, tu app usa el proxy de autenticación de Cloud SQL integrado en el entorno de Google Kubernetes Engine para comunicarse con tu instancia de Cloud SQL. Sin embargo, para probar tu aplicación de manera local, debes instalar y usar una copia local del proxy en tu entorno de desarrollo. Para obtener más detalles, consulta la guía del proxy de Cloud SQL Auth.

El proxy de autenticación de Cloud SQL usa la API de Cloud SQL para interactuar con tu instancia de SQL. Para ello, se requiere la autenticación de la aplicación a través de gcloud CLI.

Autentica y adquiere credenciales para la API:
```
gcloud auth application-default login
```
Descarga e instala el proxy de Cloud SQL Auth en tu máquina local.
Linux de 64 bits
1. Descarga el proxy de autenticación de Cloud SQL:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.amd64
2. Haz que el proxy de autenticación de Cloud SQL sea ejecutable:
  chmod +x cloud-sql-proxy
Linux de 32 bits
1. Descarga el proxy de autenticación de Cloud SQL:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.386
2. Si no se encuentra el comando curl, ejecuta sudo apt install curl y repite el comando de descarga.
3. Haz que el proxy de autenticación de Cloud SQL sea ejecutable:
  chmod +x cloud-sql-proxy
macOS de 64 bits
1. Descarga el proxy de autenticación de Cloud SQL:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.darwin.amd64
2. Haz que el proxy de autenticación de Cloud SQL sea ejecutable:
  chmod +x cloud-sql-proxy
Mac M1
1. Descarga el proxy de autenticación de Cloud SQL:
  curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.darwin.arm64
2. Haz que el proxy de autenticación de Cloud SQL sea ejecutable:
  chmod +x cloud-sql-proxy
Windows de 64 bits
Haz clic con el botón derecho en https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x64.exe y selecciona Guardar vínculo como para descargar el proxy de autenticación de Cloud SQL. Cambia el nombre del archivo por cloud-sql-proxy.exe.

Windows de 32 bits
Haz clic con el botón derecho en https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x86.exe y selecciona Guardar vínculo como para descargar el proxy de autenticación de Cloud SQL. Cambia el nombre del archivo por cloud-sql-proxy.exe.
Imagen de Docker del proxy de Cloud SQL

El proxy de autenticación de Cloud SQL tiene diferentes imágenes de contenedor, como distroless, alpine y buster. La imagen de contenedor del proxy de autenticación de Cloud SQL predeterminada usa distroless, que no contiene shell. Si necesitas una shell o herramientas relacionadas, descarga una imagen basada en alpine o buster. Para obtener más información, consulta Imágenes de contenedor del proxy de autenticación de Cloud SQL.

Puedes extraer la última imagen a tu máquina local con Docker a través del siguiente comando:
```
docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.1
```
Nota: El proxy de autenticación de Cloud SQL usa un repositorio que admite el dominio gcr.io, pero entrega imágenes de Artifact Registry. Para obtener más información, consulta Transición desde Container Registry.
Otro SO
Para otros sistemas operativos que no se incluyen aquí, puedes compilar el proxy de autenticación de Cloud SQL desde la fuente.
Puedes mover la descarga a un lugar común, como una ubicación en tu PATH o tu directorio principal. Si decides hacerlo, cuando inicies el proxy de autenticación de Cloud SQL más adelante en el instructivo, recuerda hacer referencia a la ubicación que elegiste cuando uses los comandos cloud-sql-proxy.

Crea servicios de respaldo

En este instructivo, se usan varios Google Cloud servicios para proporcionar la base de datos, el almacenamiento de medios y el almacenamiento de secretos que admiten el proyecto de Django implementado. Estos servicios se implementan en una región específica. Para lograr eficiencia entre los servicios, todos deben implementarse en la misma región. Para obtener más información sobre la región más cercana a ti, consulta Productos disponibles por región.

Configura una instancia de Cloud SQL para PostgreSQL

Django admite oficialmente varias bases de datos relacionales, pero ofrece la mayor compatibilidad con PostgreSQL. Cloud SQL admite PostgreSQL, por lo que en este instructivo se elige usar ese tipo de base de datos.

En la siguiente sección, se describe la creación de una instancia, una base de datos y un usuario de base de datos de PostgreSQL para la app.

Crea la instancia de PostgreSQL:
Console
1. En la consola de Google Cloud , ve a la página Instancias de Cloud SQL.
  
  Ir a la página Instancias de Cloud SQL
2. Haga clic en Crear instancia.
3. Haz clic en Elegir PostgreSQL.
4. En SQL Edition, elige "Enterprise".
5. En Ajuste predeterminado de edición, elige "Zona de pruebas".
6. En el campo ID de instancia, ingresa INSTANCE_NAME.
7. Ingresa una contraseña para el usuario de postgres.
8. Mantén los valores predeterminados en los otros campos.
9. Haz clic en Crear instancia.
La instancia tarda unos minutos en estar lista para su uso.
gcloud
- Crea la instancia de PostgreSQL:
  gcloud sql instances create INSTANCE_NAME \ --project PROJECT_ID \ --database-version POSTGRES_16 \ --tier db-n1-standard-2 \ --region REGION
Reemplaza lo siguiente:
- INSTANCE_NAME: El nombre de la instancia de Cloud SQL
- PROJECT_ID: Es el ID del proyecto de Google Cloud .
- REGION: La región deGoogle Cloud
La instancia demora unos minutos en crearse y estar lista para su uso.
Dentro de la instancia creada, crea una base de datos:
Console
1. En la página de tu instancia, ve a la pestaña Bases de datos.
2. Haz clic en Crear base de datos.
3. En el diálogo Database Name, ingresa DATABASE_NAME.
4. Haz clic en Crear.
gcloud
- Crea la base de datos en la instancia creada recientemente:
  gcloud sql databases create DATABASE_NAME \ --instance INSTANCE_NAME
  Reemplaza DATABASE_NAME por un nombre para la base de datos dentro de la instancia.
Crea un usuario de base de datos:

Nota: Los usuarios creados de esta manera obtienen derechos adicionales de la base de datos. Consulta Limita los privilegios del usuario de la base de datos para conocer un método alternativo.
Console
1. En la página de tu instancia, ve a la pestaña Usuarios.
2. Haz clic en Agregar cuenta de usuario.
3. En el diálogo Elige la forma de autenticación, en "Autenticación integrada", haz lo siguiente:
4. Ingresa el nombre de usuario DATABASE_USERNAME.
5. Ingresa la contraseña DATABASE_PASSWORD
6. Haga clic en Agregar.
gcloud
- Crea el usuario en la instancia creada recientemente:
  gcloud sql users create DATABASE_USERNAME \ --instance INSTANCE_NAME \ --password DATABASE_PASSWORD
  Reemplaza PASSWORD por una contraseña segura.

Cree una cuenta de servicio

El proxy requiere una cuenta de servicio con privilegios de Editor para tu instancia de Cloud SQL. Para obtener más información sobre las cuentas de servicio, consulta la descripción general de la autenticación.Google Cloud

Si te conectas desde Compute Engine, asegúrate de que tu VM tenga el scope adecuado para conectarse con la API de Administrador de Cloud SQL.

Configura la cuenta de servicio para que tenga uno de los siguientes permisos de acceso:

https://www.googleapis.com/auth/sqlservice.admin
https://www.googleapis.com/auth/cloud-platform

En la consola de Google Cloud , ve a la página Cuentas de servicio.
Ir a Cuentas de servicio
Selecciona el proyecto que contiene la instancia de Cloud SQL.
Haga clic en Crear cuenta de servicio.
En el campo Nombre de la cuenta de servicio, ingresa un nombre descriptivo para la cuenta de servicio.
Cambia el ID de la cuenta de servicio a un valor único y reconocible y, luego, haz clic en Crear y continuar.
Haz clic en el campo Seleccionar un rol y selecciona uno de los siguientes roles:
- Cloud SQL > Cliente de Cloud SQL
- Cloud SQL > Editor de Cloud SQL
- Cloud SQL > Administrador de Cloud SQL
Haz clic en Listo para terminar de crear la cuenta de servicio.
Haz clic en el menú de acciones de tu nueva cuenta de servicio y, luego, selecciona Administrar claves.
Haz clic en el menú desplegable Agregar clave y, luego, en Crear clave nueva.
Confirma que el tipo de clave sea JSON y, luego, haz clic en Crear.
El archivo de claves privadas se descargará en tu equipo. Puedes moverlo a otra ubicación. Protege el archivo de clave.

Configura la base de datos

Usa los siguientes comandos a fin de configurar variables de entorno para acceder a la base de datos. Estas variables de entorno se usan para las pruebas locales.

Linux/macOS

export DATABASE_NAME=DATABASE_NAME
export DATABASE_USER=DATABASE_USERNAME
export DATABASE_PASSWORD=DATABASE_PASSWORD

Windows

set DATABASE_USER=DATABASE_USERNAME
set DATABASE_PASSWORD=DATABASE_PASSWORD

Establece tu configuración de GKE

Esta aplicación se representa en una sola configuración de Kubernetes llamada polls. En polls.yaml, reemplaza <your-project-id> por el ID de tu proyectoGoogle Cloud (PROJECT_ID).

Ejecuta el siguiente comando y anota el valor de connectionName:

gcloud sql instances describe INSTANCE_NAME --format "value(connectionName)"

En el archivo polls.yaml, reemplaza <your-cloudsql-connection-string> por el valor connectionName.

Cómo ejecutar la app en una computadora local

Con los servicios de respaldo configurados, ahora puedes ejecutar la app en tu computadora. Esta configuración permite el desarrollo local, la creación de un superusuario y la aplicación de migraciones de bases de datos.

En una terminal independiente, inicia el proxy de Cloud SQL Auth:
Linux/macOS
```
./cloud-sql-proxy PROJECT_ID:REGION:INSTANCE_NAME
```
Windows
```
cloud-sql-proxy.exe PROJECT_ID:REGION:INSTANCE_NAME
```
En este paso, se establece una conexión entre tu computadora local y tu instancia de Cloud SQL a fin de realizar pruebas locales. Mantén el proxy de autenticación de Cloud SQL en ejecución durante todo el tiempo que realices pruebas locales en tu app. Ejecutar este proceso en una terminal separada te permite seguir trabajando mientras se ejecuta.
En la terminal original, establece el ID del proyecto de forma local:
Linux/macOS
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Windows
```
set GOOGLE_CLOUD_PROJECT=PROJECT_ID
```

Ejecuta las migraciones de Django para configurar tus modelos y recursos:

python manage.py makemigrations
python manage.py makemigrations polls
python manage.py migrate
python manage.py collectstatic

Inicia el servidor web de Django:
```
python manage.py runserver 8080
```
En tu navegador, ve a http://localhost:8080.

Si estás en Cloud Shell, haz clic en el botón Vista previa en la Web y selecciona Vista previa en el puerto 8080.

En la página, se muestra el siguiente texto: “Hello, world. You're at the polls index”. El servidor web de Django que se ejecuta en tu computadora proporciona las páginas de la app de muestra.
Presiona Ctrl/Cmd+C para detener el servidor web local.

Usar la Consola del administrador de Django

Para acceder a la consola de administración de Django, debes crear un superusuario. Como tienes una conexión a la base de datos a la que se puede acceder de forma local, puedes ejecutar comandos de administración:

Crea un superusuario. Se te pedirá que ingreses un nombre de usuario, un correo electrónico y una contraseña.
```
python manage.py createsuperuser
```
Inicia un servidor web local:
```
python manage.py runserver
```
En tu navegador, ve a http://localhost:8000/admin.
Accede al sitio del administrador con el nombre de usuario y la contraseña que usaste cuando ejecutaste createsuperuser.

Implementa la app en GKE

Cuando la app se implementa en Google Cloud, usa el servidor Gunicorn. Como Gunicorn no procesa contenido estático, la app usa a Cloud Storage para ello.

Recopila y sube recursos estáticos

Crea un bucket de Cloud Storage y haz que se pueda leer públicamente.

gcloud storage buckets create gs://PROJECT_ID_MEDIA_BUCKET
gcloud storage buckets add-iam-policy-binding gs://PROJECT_ID_MEDIA_BUCKET --member=allUsers role=roles/storage.legacyObjectReader

Recopila todo el contenido estático en una carpeta de manera local:
```
python manage.py collectstatic
```

Sube el contenido estático a Cloud Storage:

gcloud storage rsync ./static gs://PROJECT_ID_MEDIA_BUCKET/static --recursive

En mysite/settings.py, configura el valor de STATIC_URL como la siguiente URL y reemplaza [YOUR_GCS_BUCKET] por el nombre de tu depósito:
```
http://storage.googleapis.com/PROJECT_ID_MEDIA_BUCKET/static/
```

Configura GKE

Para inicializar GKE, ve a la página Clústeres.

IR A LA PÁGINA CLÚSTERES

Cuando utilizas GKE por primera vez en un proyecto, debes esperar a que desaparezca el mensaje "Kubernetes Engine is getting ready. This may take a minute or more".
Crear un clúster de GKE:
```
gcloud container clusters create polls \
  --scopes "https://www.googleapis.com/auth/userinfo.email","cloud-platform" \
  --num-nodes 4 --zone "us-central1-a"
```
Si aparece un mensaje de error similar a Project is not fully initialized with the default service accounts, es posible que debas inicializar Google Kubernetes Engine.

Inicializa GKE

Si recibiste un error, ve a la consola de Google Cloud para inicializar GKE en tu proyecto.

Ir a la página Clústeres

Espera que el mensaje "Kubernetes Engine is getting ready. This can take a minute or more" desaparezca.
Después de crear el clúster, usa la herramienta de línea de comandos de kubectl, que está integrada en la CLI de gcloud, para interactuar con tu clúster de GKE. Dado que gcloud y kubectl son herramientas independientes, asegúrate de que kubectl esté configurado para interactuar con el clúster correcto.
```
gcloud container clusters get-credentials polls --zone "us-central1-a"
```

Configura Cloud SQL

Necesitas varios secretos para habilitar la conexión de tu app de GKE con tu instancia de Cloud SQL. Se requiere uno para el acceso a nivel de instancia (conexión), mientras que los otros dos se requieren para acceder a la base de datos. Para obtener más información sobre los dos niveles de control de acceso, consulta Control de acceso de instancias.
1. Si deseas crear el secreto para el acceso a nivel de instancia, proporciona la ubicación, PATH_TO_CREDENTIAL_FILE, de la clave de la cuenta de servicio JSON que descargaste cuando creaste tu cuenta de servicio (consulta Crea una cuenta de servicio):
```
kubectl create secret generic cloudsql-oauth-credentials \
  --from-file=credentials.json=PATH_TO_CREDENTIAL_FILE
```
2. Para crear los secretos para el acceso a la base de datos, usa la base de datos SQL, el nombre de usuario y la contraseña que definiste cuando creaste los servicios de respaldo. Consulta Cómo configurar una instancia de Cloud SQL para PostgreSQL:
```
kubectl create secret generic cloudsql \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=DATABASE_USERNAME \
  --from-literal=password=DATABASE_PASSWORD
```
Recupera la imagen pública de Docker para el proxy de Cloud SQL.
```
docker pull b.gcr.io/cloudsql-docker/gce-proxy
```
Compila una imagen de Docker y reemplaza <your-project-id> con tu ID del proyecto.
```
docker build -t gcr.io/PROJECT_ID/polls .
```
Configura Docker para que use gcloud como auxiliar de credenciales y envía la imagen a Container Registry:
```
gcloud auth configure-docker
```
Envía la imagen de Docker. Reemplaza <your-project-id> con el ID del proyecto.
```
docker push gcr.io/PROJECT_ID/polls
```
Nota: Este comando requiere acceso de escritura a Cloud Storage. Si ejecutas este instructivo en una instancia de Compute Engine, es posible que tu acceso a Cloud Storage sea de solo lectura. Para obtener acceso de escritura, crea una cuenta de servicio y usa la cuenta de servicio para autenticarte en tu instancia.
Crea el recurso de GKE:
```
kubectl create -f polls.yaml
```
Nota: Si usaste nombres diferentes (que no sean cloudsql-oauth-credentials ni cloudsql) cuando creaste los secretos en los comandos anteriores, debes actualizar el archivo polls.yaml para que coincida con esos nombres nuevos.

Implementar la app en GKE.

Después de crear los recursos, hay tres Pod de polls en el clúster. Verifica el estado de los pods:

kubectl get pods

Espera unos minutos para que los estados del pod se muestren como Running. Si los pods no están listos o si ves reinicios, puedes revisar los registros de cada pod para averiguar el problema. [YOUR-POD-ID] es una parte del resultado que muestra el comando kubectl get pods anterior.

kubectl logs [YOUR_POD_ID]

Ver la app ejecutándose en Google Cloud

Una vez que los pods estén listos, puedes obtener la dirección IP externa del balanceador de cargas:

kubectl get services polls

Toma nota de la dirección EXTERNAL-IP y ve a http://[EXTERNAL-IP] en tu navegador para ver la página de destino de las encuestas de Django y acceder a la Consola del administrador.

Examina el código

Aplicación de muestra

La app de muestra de Django se creó con las herramientas estándar de Django. Con los siguientes comandos, se crea el proyecto y la app de encuestas:

django-admin startproject mysite
python manage.py startapp polls

Las vistas, los modelos y las configuraciones de rutas base se copiaron de Escribir tu primera app de Django (Parte 1 y Parte 2).

Configuración de la base de datos

settings.py contiene la configuración de tu base de datos de SQL:

DATABASES = {
    "default": {
        # If you are using Cloud SQL for MySQL rather than PostgreSQL, set
        # 'ENGINE': 'django.db.backends.mysql' instead of the following.
        "ENGINE": "django.db.backends.postgresql",
        "NAME": os.getenv("DATABASE_NAME"),
        "USER": os.getenv("DATABASE_USER"),
        "PASSWORD": os.getenv("DATABASE_PASSWORD"),
        "HOST": "127.0.0.1",
        "PORT": "5432",
    }
}

Configuraciones de Pod de Kubernetes

El archivo polls.yaml especifica dos recursos de Kubernetes. El primero es el Service, que define un nombre coherente y una dirección IP interna para la app web de Django. El segundo es un balanceador de cargas HTTP con una dirección IP externa pública.

# The polls service provides a load-balancing proxy over the polls app
# pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://kubernetes.io/docs/concepts/services-networking/service/
# For more information about external HTTP load balancing see:
#   https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
apiVersion: v1
kind: Service
metadata:
  name: polls
  labels:
    app: polls
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: polls

El servicio proporciona un nombre de red y una dirección IP. Los pods de GKE ejecutan el código de la aplicación detrás el servicio. El archivo polls.yaml especifica una implementación que proporciona actualizaciones declarativas a los pods de GKE. El servicio dirige el tráfico a la implementación. Para ello, hace coincidir el selector del servicio con la etiqueta de implementación. En este caso, el selector polls coincide con la etiqueta polls.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  selector:
    matchLabels:
      app: polls
  template:
    metadata:
      labels:
        app: polls
    spec:
      containers:
      - name: polls-app
        # Replace  with your project ID or use `make template`
        image: gcr.io/<your-project-id>/polls
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        env:
            - name: DATABASE_NAME
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: database
            - name: DATABASE_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: gcr.io/cloudsql-docker/gce-proxy:1.16
        name: cloudsql-proxy
        command: ["/cloud_sql_proxy", "--dir=/cloudsql",
                  "-instances=<your-cloudsql-connection-string>=tcp:5432",
                  "-credential_file=/secrets/cloudsql/credentials.json"]
        volumeMounts:
          - name: cloudsql-oauth-credentials
            mountPath: /secrets/cloudsql
            readOnly: true
          - name: ssl-certs
            mountPath: /etc/ssl/certs
          - name: cloudsql
            mountPath: /cloudsql
      volumes:
        - name: cloudsql-oauth-credentials
          secret:
            secretName: cloudsql-oauth-credentials
        - name: ssl-certs
          hostPath:
            path: /etc/ssl/certs
        - name: cloudsql
          emptyDir: {}

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo su contenido. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los IDs personalizados de los proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID personalizado del proyecto que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

En la Google Cloud consola, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra los recursos individuales

Si no quieres borrar el proyecto, borra los recursos individuales.

Borra el clúster de Google Kubernetes Engine:
```
gcloud container clusters delete polls
```
Borra la imagen de Docker que enviaste a Container Registry:
```
gcloud container images delete gcr.io/PROJECT_ID/polls
```

Borra la instancia de Cloud SQL:

gcloud sql instances delete INSTANCE_NAME

¿Qué sigue?

Aprende a configurar PostgreSQL para la producción
Obtén más información sobre Django en Google Cloud

Ejecuta Django en Google Kubernetes Engine Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Objetivos

Costos

Antes de comenzar

Prepara el entorno

Clona una app de ejemplo

Linux/macOS

Windows

Confirma tu configuración de Python

Linux/macOS

Windows

Descarga el proxy de Cloud SQL Auth para conectarte a Cloud SQL desde tu máquina local

Linux de 64 bits

Linux de 32 bits

macOS de 64 bits

Mac M1

Windows de 64 bits

Windows de 32 bits

Imagen de Docker del proxy de Cloud SQL

Otro SO

Crea servicios de respaldo

Configura una instancia de Cloud SQL para PostgreSQL

Console

gcloud

Console

gcloud

Console

gcloud

Cree una cuenta de servicio

Configura la base de datos

Linux/macOS

Windows

Establece tu configuración de GKE

Cómo ejecutar la app en una computadora local

Linux/macOS

Windows

Linux/macOS

Windows

Usar la Consola del administrador de Django

Implementa la app en GKE

Recopila y sube recursos estáticos

Configura GKE

Inicializa GKE

Configura Cloud SQL

Implementar la app en GKE.

Ver la app ejecutándose en Google Cloud

Examina el código

Aplicación de muestra

Configuración de la base de datos

Configuraciones de Pod de Kubernetes

Realiza una limpieza

Borra el proyecto

Borra los recursos individuales

¿Qué sigue?

Ejecuta Django en Google Kubernetes Engine