Ejecutar Django en Kubernetes Engine

Es muy fácil empezar a desarrollar aplicaciones de Django que se ejecutan en Google Kubernetes Engine. Además, debido a que las aplicaciones que crees se ejecutarán en la misma infraestructura que se usa en todos los productos de Google, puedes tener la tranquilidad de que se escalarán para atender a todos tus usuarios, ya sean unos pocos o millones de ellos.

En este tutorial se da por hecho que conoces el desarrollo web de Django. Aprenderás sobre el despliegue de la aplicación tutorial oficial de Django que trata sobre cómo escribir tu primera aplicación de Django. Es una buena idea que empieces con ese tutorial antes de trabajar con este, sobre todo si es la primera vez que te enfrentas al desarrollo de Django. Los modelos de la aplicación representan encuestas que contienen preguntas; puedes interactuar con los modelos usando la consola de administración de Django.

Para este tutorial se necesitan las versiones 2.7 o 3.4 de Python. También tienes que tener Docker instalado.

Antes de empezar

Marca los pasos a medida que los completas.

  1. check_box_outline_blank check_box Crea un proyecto en la consola de Google Cloud Platform.
    Si aún no has creado un proyecto, crea uno ahora. Los proyectos te permiten administrar todos los recursos de Google Cloud Platform para tu aplicación, incluido el despliegue, el control de acceso, la facturación y los servicios.
    1. Abre la consola de GCP.
    2. En el menú desplegable de la parte superior, selecciona Crear proyecto.
    3. Haz clic en Mostrar opciones avanzadas. En la ubicación de App Engine, selecciona una ubicación en Estados Unidos.
    4. Asigna un nombre a tu proyecto.
    5. Anota el ID del proyecto, que puede ser diferente al nombre del proyecto. El ID del proyecto se usa en comandos y configuraciones.
  2. check_box_outline_blank check_box Habilita la facturación para tu proyectoy regístrate para obtener una versión de prueba gratuita.

    Si todavía no has habilitado la facturación para tu proyecto, habilita la facturación ahoray regístrate para obtener una versión de prueba gratuita. Al habilitar la facturación, se le permite a la aplicación utilizar recursos facturables, como ejecutar instancias y almacenar datos. Durante el periodo de prueba gratuito, no se te cobrará ningún servicio.

  3. check_box_outline_blank check_box Instala el SDK de Google Cloud.

    Si aún no lo has hecho, instala e inicializa el SDK de Google Cloud ahora. El SDK contiene herramientas y bibliotecas que te permiten crear y administrar recursos en Google Cloud Platform.

  4. check_box_outline_blank check_box Habilita las API para tu proyecto.

    Esta acción te lleva a la consola de GCP y habilita automáticamente las API utilizadas en este tutorial. Las API utilizadas son: la API de Google Cloud SQL, la API de Compute Engine.

Descargar y ejecutar la aplicación

Una vez que hayas completado los requisitos previos, puedes descargar y desplegar la aplicación de muestra de Django. En las siguientes secciones aprenderás a configurar, ejecutar y desplegar la muestra.

Clonar la aplicación de Django

El código de la aplicación de muestra de Django se encuentra en el repositorio de muestras de Python de Google Cloud Platform en GitHub.

Clona 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:

cd python-docs-samples/container_engine/django_tutorial

También puedes descargar la muestra en formato zip y extraerla.

Configurar tu entorno local

Cuando se despliega, tu aplicación utiliza el proxy de Cloud SQL que está integrado en el entorno de App Engine para comunicarse con tu instancia de Cloud SQL. Sin embargo, para probar tu aplicación a nivel local, debes instalar y usar una copia local del proxy de Cloud SQL en tu entorno de desarrollo.

Obtén más información sobre el proxy de Cloud SQL.

Para realizar tareas administrativas básicas en tu instancia de Cloud SQL, puedes utilizar el cliente de PostgreSQL.

Instalar el proxy de SQL

Descarga e instala el proxy de Cloud SQL. El proxy de Cloud SQL se usa para conectarte a tu instancia de Cloud SQL cuando se ejecuta localmente.

Linux de 64 bits

  1. Descarga el proxy:
    wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.amd64 -O cloud_sql_proxy
    
  2. Permite que el proxy sea ejecutable:
    chmod +x cloud_sql_proxy
    

Linux de 32 bits

  1. Descarga el proxy:
    wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.386 -O cloud_sql_proxy
    
  2. Permite que el proxy sea ejecutable:
    chmod +x cloud_sql_proxy
    

macOS de 64 bits

  1. Descarga el proxy:
    curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.amd64
    
  2. Permite que el proxy sea ejecutable:
    chmod +x cloud_sql_proxy
    

macOS de 32 bits

  1. Descarga el proxy:
    curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.386
    
  2. Permite que el proxy sea ejecutable:
    chmod +x cloud_sql_proxy
    

Windows de 64 bits

Haz clic con el botón derecho en https://dl.google.com/cloudsql/cloud_sql_proxy_x64.exe, selecciona "Guardar enlace como..." para descargar el proxy y cámbiale el nombre a cloud_sql_proxy.exe.

Windows de 32 bits

Haz clic con el botón derecho en https://dl.google.com/cloudsql/cloud_sql_proxy_x86.exe, selecciona "Guardar enlace como..." para descargar el proxy y cámbiale el nombre a cloud_sql_proxy.exe.
Si tu sistema operativo no está incluido en esta lista, también puedes compilar el proxy desde el origen.

Crear una instancia de Cloud SQL

  1. Crea una instancia de Cloud SQL for PostgreSQL.

    Asígnale el nombre polls-instance u otro similar a la instancia. La instancia puede tardar unos minutos en estar lista. Una vez que la instancia esté preparada, debería poder verse en la lista de instancias.

  2. Ahora, usa el SDK de Google Cloud desde la línea de comandos para ejecutar el siguiente comando. Copia el valor que se muestra en connectionName para llevar a cabo el siguiente paso.
    gcloud sql instances describe [YOUR_INSTANCE_NAME]

    El valor de connectionName tiene el formato [PROJECT_NAME]:[REGION_NAME]:[INSTANCE_NAME].

Inicializar tu instancia de Cloud SQL

  1. Inicia el proxy de Cloud SQL utilizando el valor de connectionName del paso anterior.

    Linux/Mac OS X

    ./cloud_sql_proxy -instances="[YOUR_INSTANCE_CONNECTION_NAME]"=tcp:5432

    Windows

    cloud_sql_proxy.exe -instances="[YOUR_INSTANCE_CONNECTION_NAME]"=tcp:5432

    Sustituye [YOUR_INSTANCE_CONNECTION_NAME] por el valor de connectionName que has registrado en el paso anterior.

    En este paso se establece una conexión desde tu ordenador local hasta tu instancia de Cloud SQL con fines de pruebas locales. No interrumpas la ejecución del proxy de Cloud SQL en ningún momento mientras pruebas tu aplicación a nivel local.

  2. A continuación, crea un nuevo usuario y base de datos de Cloud SQL.

    CONSOLA

    1. Crea una nueva base de datos usando la consola de GCP para tu instancia de Cloud SQL polls-instance. Puedes usar el nombre polls, por ejemplo.
    2. Crea un nuevo usuario utilizando la consola de GCP para tu instancia de Cloud SQL polls-instance.

    CLIENTE DE POSTGRES

    1. En una pestaña de línea de comandos independiente, instala el cliente de Postgres.
      sudo apt-get install postgresql
      
    2. Usa el cliente de Postgres o un programa similar para conectarte a tu instancia. Cuando se te solicite, usa la contraseña raíz que hayas configurado.
      psql --host 127.0.0.1 --user postgres --password
      
    3. Crea las bases de datos, los usuarios y los permisos de acceso requeridos en tu base de datos de Cloud SQL usando los siguientes comandos. Sustituye [POSTGRES_USER] y [POSTGRES_PASSWORD] por el nombre de usuario y contraseña que elijas.
      CREATE DATABASE polls;
      CREATE USER [POSTGRES_USER] WITH PASSWORD '[POSTGRES_PASSWORD]';
      GRANT ALL PRIVILEGES ON DATABASE polls TO [POSTGRES_USER];
      GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO [POSTGRES_USER];
      

Crear 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 guía de autenticación de Google Cloud Platform.

  1. Ve a la página sobre cuentas de servicio de Cloud SQL de la consola de Google Cloud Platform.

    Ir a la página sobre cuentas de servicio

  2. Si es necesario, selecciona el proyecto que contiene tu instancia de Cloud SQL.
  3. Haz clic en Crear cuenta de servicio.
  4. En el cuadro de diálogo Crear cuenta de servicio, proporciona un nombre descriptivo para la cuenta.
  5. En Función, selecciona Cloud SQL > Cliente de Cloud SQL.
  6. Cambia el ID de la cuenta de servicio a un valor único que puedas reconocer para encontrar fácilmente esta cuenta de servicio más tarde si es necesario.
  7. Haz clic en Suministrar una nueva clave privada.
  8. El tipo de clave predeterminada es JSON, que es el valor correcto que se debe usar.
  9. Haz clic en Crear.

    El archivo de clave privada se descarga en tu máquina. Puedes moverlo a otra ubicación. Mantén protegido el archivo de clave.

Configurar los ajustes de la base de datos

  1. Establece variables de entorno para el acceso a la base de datos para pruebas locales.

Linux/Mac OS X

export DATABASE_USER=<your-database-user>
export DATABASE_PASSWORD=<your-database-password>

Windows

set DATABASE_USER=<your-database-user>
set DATABASE_PASSWORD=<your-database-password>

Configurar tus ajustes de Kubernetes

  1. Esta aplicación se representa en una sola configuración de Kubernetes, llamada polls. En polls.yaml, sustituye <your-project-id> por tu ID del proyecto.

  2. En polls.yaml, sustituye <your-cloudsql-connection-string> por el valor de connectionName generado a partir del siguiente comando:

    gcloud beta sql instances describe [YOUR_INSTANCE_NAME]
    

Ejecutar la aplicación en tu ordenador local

  1. Para ejecutar la aplicación Django en tu ordenador local, deberás configurar un entorno de desarrollo de Python que incluya Python, pip y virtualenv. Para obtener instrucciones, consulta la sección de configuración de un entorno de desarrollo de Python para Google Cloud Platform.

  2. Crea un entorno de Python aislado e instala dependencias:

    virtualenv env
    source env/bin/activate
    pip install -r requirements.txt
    
  3. Ejecuta las migraciones de Django para configurar tus modelos:

    python manage.py makemigrations
    python manage.py makemigrations polls
    python manage.py migrate
    
  4. Inicia un servidor web local:

    python manage.py runserver
    
  5. En el navegador web, accede a http://localhost:8000.

Deberías poder ver una página web sencilla en la que figure el siguiente texto: "Hello, world. You're at the polls index" (Hola, mundo. Esto es el índice de encuestas). El servidor web de Django que se está ejecutando en tu ordenador envía las páginas de la aplicación de muestra. Cuando quieras continuar, pulsa Ctrl + C para detener el servidor web local.

Usar la consola de administración de Django

  1. Crea un superusuario:

    python manage.py createsuperuser
    
  2. Ejecuta el programa principal:

    python manage.py runserver
    
  3. En el navegador web, accede a http://localhost:8000/admin.

  4. Para iniciar sesión en el sitio de administración, usa el nombre de usuario y la contraseña que creaste al ejecutar createsuperuser.

Desplegar la aplicación en Kubernetes Engine

  1. Cuando la aplicación se despliega en Google Cloud Platform, utiliza el servidor de Gunicorn. Gunicorn no ofrece contenido estático, por lo que la aplicación utiliza Google Cloud Storage para suministrar contenido estático.

    Crea un segmento de Cloud Storage y permite que sea legible públicamente. Sustituye <your-gcs-bucket> por el nombre de segmento que quieras. Por ejemplo, puedes usar tu ID del proyecto como nombre de segmento:

    gsutil mb gs://<your-gcs-bucket>
    gsutil defacl set public-read gs://<your-gcs-bucket>
    
  2. Reúne todo el contenido estático a nivel local en una sola carpeta:

    python manage.py collectstatic
    
  3. Sube el contenido estático a CloudStorage:

    gsutil rsync -R static/ gs://<your-gcs-bucket>/static
    
  4. En mysite/settings.py, utiliza esta URL para el valor de STATIC_URL, sustituyendo <your-gcs-bucket> por el nombre de tu segmento.

    http://storage.googleapis.com/<your-gcs-bucket>/static/
    
  5. Accede a la consola de Kubernetes Engine para inicializar Kubernetes Egine. Espera a que desaparezca el siguiente mensaje: "Kubernetes Engine is getting ready. This may take a minute or more" (Kubernetes Engine se está preparando. Esto puede tardar uno o varios minutos).

  6. Crea un clúster de Kubernetes Engine:

    gcloud container clusters create polls \
      --scopes "https://www.googleapis.com/auth/userinfo.email","cloud-platform" \
      --num-nodes 4 --zone "us-central1-a"
    

    Comprueba si aparece el siguiente error: "Project [PROJECT_ID] is not fully initialized with the default service accounts" (El proyecto [PROJECT_ID] no se ha inicializado completamente en las cuentas de servicio predeterminadas).

    Inicializa Kubernetes Engine

    Si aparece un error, accede a la consola para inicializar Kubernetes Engine en tu proyecto:

    Ir a la página de Kubernetes Engine

    Espera a que desaparezca el siguiente mensaje: "Kubernetes Engine is getting ready. This can take a minute or more" (Kubernetes Engine se está preparando. Esto puede tardar uno o varios minutos).

  7. Después de crear el clúster, utiliza la herramienta de línea de comandos kubectl, integrada con la herramienta gcloud, para interactuar con tu clúster de Kubernetes. Como gcloud y kubectl son herramientas independientes, debes asegurarte de que kubectl esté configurado para interactuar con el clúster correcto:

    gcloud container clusters get-credentials polls --zone "us-central1-a"
    
  8. Necesitas varios secretos para habilitar tu aplicación de Google Kubernetes Engine y así conectarte con tu instancia de Cloud SQL. Uno es necesario para el acceso a nivel de instancia (conexión), mientras que los otros dos son necesarios para el acceso a la base de datos. Para obtener más información acerca de los dos niveles de control de acceso, consulta la sección sobre control de acceso de instancias.

    1. Crea el secreto para el acceso a nivel de instancia, proporcionando la ubicación de la clave que descargaste cuando creaste tu cuenta de servicio:

      kubectl create secret generic cloudsql-oauth-credentials --from-file=credentials.json=[PATH_TO_CREDENTIAL_FILE]
      
    2. Crea los secretos necesarios para el acceso a la base de datos:

      kubectl create secret generic cloudsql --from-literal=username=[PROXY_USERNAME] --from-literal=password=[PASSWORD]
      
  9. Ejecuta este comando para obtener la imagen pública de Docker para el proxy de Cloud SQL.

    docker pull b.gcr.io/cloudsql-docker/gce-proxy:1.05
    
  10. Compila una imagen de Docker, reemplazando <your-project-id> por tu ID del proyecto.

    docker build -t gcr.io/<your-project-id>/polls .
    
  11. Introduce la imagen de Docker en Google Container Registry reemplazando <your-project-id> por tu ID del proyecto.

    gcloud docker -- push gcr.io/<your-project-id>/polls
    
  12. Crea el recurso de Kubernetes:

    kubectl create -f polls.yaml
    
  13. Después de crear los recursos, deberá haber tres pods de polls en el clúster. Verifica el estado de tus pods:

    kubectl get pods
    

    Espera unos minutos hasta que los estados de los pods cambien a Running. Si los pods no están listos o ves reinicios, puedes obtener los registros de un pod en particular para resolver el problema:

    kubectl logs <your-pod-id>
    

Ver la aplicación ejecutada en la nube

Una vez que los pods estén listos, podrás obtener la dirección IP pública del balanceador de carga:

kubectl get services polls

Introduce la dirección EXTERNAL-IP en tu navegador para ver la página de inicio básica de Django y acceder a la consola de administración.

Comprender el código

La aplicación de muestra de Django se creó con las herramientas estándar de Django. Con estos comandos se crean el proyecto y la aplicación de encuestas:

django-admin startproject mysite
python manage.py startapp polls

El archivo 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': 'polls',
        'USER': os.getenv('DATABASE_USER'),
        'PASSWORD': os.getenv('DATABASE_PASSWORD'),
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Los archivos polls.yaml especifican dos recursos de Kubernetes. El primero es el servicio, que define un nombre y una dirección IP privada uniformes para la aplicación web de Django. El segundo es un balanceador de carga 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', Container Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://cloud.google.com/container-engine/docs/services/
# For more information about external HTTP load balancing see:
#   https://cloud.google.com/container-engine/docs/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, y los pods de Kubernetes ejecutan el código de la aplicación detrás del servicio. El archivo polls.yaml especifica un despliegue que proporciona actualizaciones declarativas para los pods de Kubernetes. El servicio dirige el tráfico al despliegue haciendo coincidir el selector del servicio con la etiqueta del despliegue. En este caso, los valores de polls del selector coinciden con la etiqueta polls.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  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_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: b.gcr.io/cloudsql-docker/gce-proxy:1.05
        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:
¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...