Ejecutar Bookshelf para Python en Compute Engine

En este tutorial, se explica cómo ejecutar la aplicación Bookshelf de Python en Google Compute Engine. Sigue las instrucciones de este tutorial para desplegar una aplicación web de Python en Compute Engine. No es necesario estar familiarizado con la aplicación Bookshelf para seguir las instrucciones de este tutorial, pero si quieres obtener más información acerca de la aplicación Bookshelf, consulta el tutorial sobre el entorno flexible de App Engine.

Objetivos

  • Desplegar la aplicación de muestra Bookshelf en una única instancia de Compute Engine.
  • Escalar la aplicación horizontalmente mediante el uso de un grupo de instancias administradas.
  • Distribuir el tráfico mediante el uso de balanceo de carga de HTTP.
  • Responder a los cambios de tráfico a través del autoescalado.

Costes

En este tutorial, se utilizan componentes facturables de Cloud Platform, tales como:

  • Google Compute Engine
  • Google Cloud Storage
  • Google Cloud Datastore
  • Google Cloud Logging
  • Google Cloud Pub/Sub

Si quieres generar una estimación de costes en función del uso proyectado, usa la calculadora de precios. Es posible que los nuevos usuarios de Cloud Platform cumplan los requisitos para obtener una versión de prueba gratuita.

Antes de empezar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. Selecciona o crea un proyecto de GCP.

    Ir a la página Administrar recursos

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. Habilita las Cloud Datastore, Cloud Storage, y Cloud Pub/Sub API necesarias.

    Habilita las API

  5. Realiza la instalación y la inicialización del SDK de Cloud.
  6. Instala Python, pip y virtualenv en el sistema. Para obtener más instrucciones, consulta la sección sobre configuración de un entorno de desarrollo con Python para Google Cloud Platform.

Crear un segmento de Cloud Storage

En las siguientes instrucciones, se explica cómo crear un segmento de Cloud Storage. Los segmentos son los contenedores básicos que retienen los datos en Cloud Storage.

Para crear un segmento, sigue estos pasos:

  1. Invoca el siguiente comando en una ventana de terminal:

    gsutil mb gs://[YOUR-BUCKET-NAME]

  2. Establece la LCA predeterminada del segmento como public-read, con ello, los usuarios podrán ver las imágenes subidas:

    gsutil defacl set public-read gs://[YOUR-BUCKET-NAME]

Clonar la aplicación de muestra

La aplicación de muestra está disponible en GitHub en GoogleCloudPlatform/getting-started-python.

  1. Clona el repositorio:

    git clone https://github.com/GoogleCloudPlatform/getting-started-python.git
    
  2. Ve al directorio de muestra:

    cd getting-started-python/7-gce
    

Configurar la aplicación

  1. Abre config.py para editarlo.

  2. Utiliza el ID del proyecto para establecer el valor de PROJECT_ID.

  3. Utiliza el nombre de segmento de Cloud Storage para establecer el valor CLOUD_STORAGE_BUCKET.

  4. Guarda y cierra config.py.

Ejecutar la aplicación en el ordenador local

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

    Linux/Mac OS X

    virtualenv env
    source env/bin/activate
    pip install -r requirements.txt
    

    Windows

    virtualenv env
    env\scripts\activate
    pip install -r requirements.txt
    

  2. Ejecuta la aplicación:

    python main.py

  3. Introduce la siguiente dirección en el navegador web:

    http://localhost:8080

Si quieres detener el servidor web local, presiona Control + C.

Realizar un despliegue en una sola instancia

Despliegue de instancia única

En esta sección, se explica cómo ejecutar una sola instancia de la aplicación en Compute Engine.

Enviar el código a un repositorio

Puedes usar Cloud Source Repositories para crear fácilmente un repositorio de Git en el proyecto y subir en él el código de la aplicación. Las instancias pueden obtener la versión más reciente del código de la aplicación del repositorio durante el inicio. Esto resulta muy práctico porque la actualización de la aplicación no requiere configurar nuevas imágenes o instancias; lo único que tienes que hacer es reiniciar una instancia o crear una nueva.

Primero, crea un repositorio aquí, en Cloud Console.

A continuación, envía el código de la aplicación al repositorio del proyecto:

git commit -am "Updating configuration"
git config credential.helper gcloud.sh
gcloud beta source repos create [YOUR_REPO]
git remote add cloud https://source.developers.google.com/p/[YOUR_PROJECT_ID]/r/[YOUR_REPO]
git push cloud

donde [YOUR_PROJECT_ID] es el ID del proyecto y [YOUR_REPO] es el nombre que le diste al repositorio que acabas de crear.

Usar una secuencia de comandos de inicio para inicializar una instancia

Ahora que las instancias de Compute Engine pueden acceder al código, necesitas un método para indicar a tu instancia que descargue y ejecute el código. Una instancia puede tener una secuencia de comandos de inicio que se ejecuta cada vez que la instancia se inicia o reinicia.

Aquí presentamos la secuencia de comandos de inicio que se incluye en la aplicación de muestra Bookshelf:

set -v

# Talk to the metadata server to get the project id
PROJECTID=$(curl -s "http://metadata.google.internal/computeMetadata/v1/project/project-id" -H "Metadata-Flavor: Google")

# Install logging monitor. The monitor will automatically pickup logs sent to
# syslog.
curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -yq \
    git build-essential supervisor python python-dev python-pip libffi-dev \
    libssl-dev

# Create a pythonapp user. The application will run as this user.
useradd -m -d /home/pythonapp pythonapp

# pip from apt is out of date, so make it update itself and install virtualenv.
pip install --upgrade pip virtualenv

# Get the source code from the Google Cloud Repository
# git requires $HOME and it's not set during the startup script.
export HOME=/root
git config --global credential.helper gcloud.sh
git clone https://source.developers.google.com/p/$PROJECTID/r/[YOUR_REPO_NAME] /opt/app

# Install app dependencies
virtualenv /opt/app/7-gce/env
/opt/app/7-gce/env/bin/pip install -r /opt/app/7-gce/requirements.txt

# Make sure the pythonapp user owns the application code
chown -R pythonapp:pythonapp /opt/app

# Configure supervisor to start gunicorn inside of our virtualenv and run the
# application.
cat >/etc/supervisor/conf.d/python-app.conf << EOF
[program:pythonapp]
directory=/opt/app/7-gce
command=/opt/app/7-gce/env/bin/gunicorn main:app --bind 0.0.0.0:8080
autostart=true
autorestart=true
user=pythonapp
# Environment variables ensure that the application runs inside of the
# configured virtualenv.
environment=VIRTUAL_ENV="/opt/app/env/7-gce",PATH="/opt/app/7-gce/env/bin",\
    HOME="/home/pythonapp",USER="pythonapp"
stdout_logfile=syslog
stderr_logfile=syslog
EOF

supervisorctl reread
supervisorctl update

# Application should now be running under supervisor

Para usar esta secuencia de comandos, substituye [YOUR_REPO_NAME] por el nombre del repositorio.

La secuencia de comandos de inicio realiza las siguientes tareas:

  • Instala el agente de Google Cloud Logging. El agente recopila automáticamente registros de syslog.

  • Instala Python y Supervisor. El supervisor se usa para ejecutar la aplicación como daemon.

  • Clona el código fuente de la aplicación de Cloud Repository e instala dependencias.

  • Configura Supervisor para que ejecute la aplicación. Supervisor se asegura de que la aplicación se reinicie si se cierra inesperadamente o un administrador u otro proceso la detiene. También envía los parámetros stdout y stderr de la aplicación a syslog para que el agente de Cloud Logging los recopile.

Crear y configurar una instancia de Compute Engine

  1. Crea una instancia de Compute Engine:

    Linux/Mac OS X

    gcloud compute instances create my-app-instance \
        --image-family=debian-8 \
        --image-project=debian-cloud \
        --machine-type=g1-small \
        --scopes userinfo-email,cloud-platform \
        --metadata-from-file startup-script=gce/startup-script.sh \
        --zone us-central1-f \
        --tags http-server
    

    Windows

    gcloud compute instances create my-app-instance ^
        --image-family=debian-8 ^
        --image-project=debian-cloud ^
        --machine-type=g1-small ^
        --scopes userinfo-email,cloud-platform ^
        --metadata-from-file startup-script=gce/startup-script.sh ^
        --zone us-central1-f ^
        --tags http-server
    

    Este comando crea una nueva instancia, le permite acceder a los servicios de Cloud Platform y ejecuta la secuencia de comandos de inicio. El nombre de la instancia es my-app-instance.

  2. Verifica el progreso de la creación de la instancia:

    gcloud compute instances get-serial-port-output my-app-instance --zone us-central1-f
    

    Si la secuencia de comandos de inicio se ha completado, aparecerá Finished running startup script cerca del final del resultado de comando.

  3. Crea una regla de cortafuegos para permitir el tráfico en la instancia:

    Linux/Mac OS X

    gcloud compute firewall-rules create default-allow-http-8080 \
        --allow tcp:8080 \
        --source-ranges 0.0.0.0/0 \
        --target-tags http-server \
        --description "Allow port 8080 access to http-server"
    

    Windows

    gcloud compute firewall-rules create default-allow-http-8080 ^
        --allow tcp:8080 ^
        --source-ranges 0.0.0.0/0 ^
        --target-tags http-server ^
        --description "Allow port 8080 access to http-server"
    

  4. Obtén la dirección IP externa de la instancia:

    gcloud compute instances list
    
  5. Si quieres ver la aplicación en ejecución, visita http://[YOUR_INSTANCE_IP]:8080,

    donde [YOUR_INSTANCE_IP] es la dirección IP externa de la instancia.

Administrar y supervisar una instancia

Puedes usar la consola de Google Cloud Platform para supervisar y administrar la instancia. En la sección Compute> Compute Engine, se puede ver la instancia en ejecución y conectarse a ella mediante SSH. En la sección Supervisión> Registros, se pueden ver todos los registros generados por los recursos de Compute Engine. Google Cloud Logging se configura de forma automática para recopilar registros de varios servicios comunes, incluido syslog.

Escalar en horizontal con varias instancias

Despliegue de varias instancias con instancias administradas

Compute Engine puede escalar en sentido horizontal fácilmente. Cuando se utiliza un grupo de instancias administrado y la herramienta de adaptación dinámica de Compute Engine, Compute Engine puede crear automáticamente nuevas instancias de la aplicación cuando sea necesario y cerrar instancias cuando la demanda sea baja. Puedes configurar un balanceador de carga HTTP para distribuir el tráfico a las instancias en un grupo de instancias administrado.

Crear un grupo de instancias administrado

Un grupo de instancias administrado es un grupo de instancias homogéneas basadas en la misma plantilla de instancia. Una plantilla de instancia define la configuración de la instancia, incluida la imagen de origen, el tamaño del disco, los permisos y los metadatos, incluidas las secuencias de comando de inicio.

  1. Primero, crea una plantilla:

    gcloud compute instance-templates create $TEMPLATE \
      --image-family $IMAGE_FAMILY \
      --image-project $IMAGE_PROJECT \
      --machine-type $MACHINE_TYPE \
      --scopes $SCOPES \
      --metadata-from-file startup-script=$STARTUP_SCRIPT \
      --tags $TAGS

  2. Luego, crea un grupo de instancias:

    gcloud compute instance-groups managed \
      create $GROUP \
      --base-instance-name $GROUP \
      --size $MIN_INSTANCES \
      --template $TEMPLATE \
      --zone $ZONE 

    El parámetro --size especifica el número de instancias en el grupo. Después de que todas las instancias hayan terminado de ejecutar sus secuencias de comando de inicio, se puede acceder a las instancias de forma individual mediante sus direcciones IP externas y el puerto 8080. Para encontrar las direcciones IP externas de las instancias, introduce lo siguiente: gcloud compute instances list. Las instancias administradas tienen nombres que comienzan con el mismo prefijo, my-app, que especificaste en el parámetro --base-instance-name.

Crear un balanceador de carga

Una instancia individual es suficiente para pruebas o depuraciones, pero para distribuir el tráfico web es mejor usar un balanceador de carga para dirigir de manera automática el tráfico a las instancias disponibles. Si quieres crear un balanceador de carga, sigue los pasos que se indican a continuación:

  1. Crea una comprobación del estado. El balanceador de carga utiliza una comprobación de estado para determinar qué instancias pueden distribuir tráfico:

    gcloud compute http-health-checks create ah-health-check \
      --request-path /_ah/health \
      --port 8080

  2. Crea un puerto con nombre. El balanceador de carga HTTP busca el servicio http para saber a qué puerto dirigir el tráfico. En el grupo de instancias, nombra como http al puerto 8080:

    gcloud compute instance-groups managed set-named-ports \
        $GROUP \
        --named-ports http:8080 \
        --zone $ZONE

  3. Crea un servicio de backend. El servicio de backend es el destino del tráfico con balanceo de carga. Define a qué grupo de instancias debe dirigirse el tráfico y qué comprobación de estado utilizar.

    gcloud compute backend-services create $SERVICE \
      --http-health-checks ah-health-check \
      --global

  4. Agrega el siguiente servicio de backend:

    gcloud compute backend-services add-backend $SERVICE \
      --instance-group $GROUP \
      --instance-group-zone $ZONE \
      --global

  5. Crea una asignación de URLs y un proxy:

    La asignación de URLs define qué URL deben dirigirse a qué servicios de backend. En esta muestra, un servicio de backend distribuye todo el tráfico. Si quieres realizar un balanceo de carga de peticiones entre varias regiones o grupos, puedes crear varios servicios de backend. Un proxy recibe tráfico y lo reenvía a los servicios de backend mediante la asignación de URLs.

    1. Crea la asignación de URLs:

      gcloud compute url-maps create $SERVICE-map \
        --default-service $SERVICE

    2. Crea el proxy:

      gcloud compute target-http-proxies create $SERVICE-proxy \
        --url-map $SERVICE-map

  6. Crea una regla de reenvío global. La regla de reenvío global vincula una dirección IP pública y un puerto a un proxy:

    gcloud compute forwarding-rules create $SERVICE-http-rule \
      --global \
      --target-http-proxy $SERVICE-proxy \
      --ports=80

Configurar la herramienta de adaptación dinámica

El balanceador de carga asegura que el tráfico se distribuya entre todas las instancias en buen estado. Pero ¿qué sucede si las instancias no pueden controlar todo el tráfico? Puedes agregar más instancias manualmente. Sin embargo, una mejor solución es configurar una herramienta de adaptación dinámica de Compute Engine para crear y eliminar instancias automáticamente frente a las demandas de tráfico.

  1. Crea una herramienta de adaptación dinámica:

    gcloud compute instance-groups managed set-autoscaling \
      $GROUP \
      --max-num-replicas $MAX_INSTANCES \
      --target-load-balancing-utilization $TARGET_UTILIZATION \
      --zone $ZONE 

    El comando anterior crea una herramienta de adaptación dinámica en el grupo de instancias administrado que realiza un escalado automático de hasta 10 instancias. Se agregan nuevas instancias cuando el balanceador de carga está por encima del 50 % de utilización y se eliminan cuando su uso cae por debajo del 50 %.

  2. Crea una regla de cortafuegos si aún no lo has hecho:

    # Check if the firewall rule has been created in previous steps of the documentation
    if gcloud compute firewall-rules list --filter="name~'default-allow-http-8080'" \
      --format="table(name)" | grep -q 'NAME'; then
      echo "Firewall rule default-allow-http-8080 already exists."
    else
      gcloud compute firewall-rules create default-allow-http-8080 \
        --allow tcp:8080 \
        --source-ranges 0.0.0.0/0 \
        --target-tags http-server \
        --description "Allow port 8080 access to http-server"
    fi
    

  3. Comprueba el estado del proceso:

    gcloud compute backend-services get-health my-app-service
    

    Continúa comprobando hasta que al menos una de las instancias informe un estado HEALTHY.

Visualizar la aplicación

  1. Obtén la dirección IP de reenvío para el balanceador de carga:

    gcloud compute forwarding-rules list --global
    

    La dirección IP de las reglas de reenvío se encuentra en la columna IP_ADDRESS.

  2. En un navegador, introduce la dirección IP de la lista. Ahora, tu aplicación de autoescalado y con balanceo de carga se ejecuta en Google Compute Engine.

Administrar y supervisar el despliegue

Administrar varias instancias es tan fácil como administrar una sola. Puedes usar la consola de GCP para supervisar el balanceo de carga, el autoescalado y el grupo de instancias administrado.

Puedes administrar el grupo de instancias y la configuración de autoescalado mediante la sección Compute > Compute Engine > Grupos de instancias.

Puedes administrar la configuración de balanceo de carga, incluidas las asignaciones de URLs y los servicios de backend, mediante la sección Compute > Compute Engine > Balanceo de carga de HTTP.

Secuencia de comandos de despliegue

La aplicación de muestra incluye una secuencia de comandos que ayuda a demostrar el despliegue en Compute Engine. La secuencia de comandos denominada deploy.sh realiza un despliegue completo, autoescalado y con balanceo de carga de la aplicación, como se describe en la sección de escalado horizontal con varias instancias.

Limpiar los recursos

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud Platform, sigue estas instrucciones:

Ejecutar la secuencia de comandos de desmontaje

Si ejecutaste la secuencia de comandos deploy.sh, ejecuta la secuencia de comandos teardown.sh para eliminar todos los recursos creados por la secuencia de comandos deploy.sh. Esto devuelve el proyecto al estado en el que estaba antes de ejecutar la secuencia de comandos deploy.sh y ayuda a evitar una facturación futura. Si quieres eliminar la instancia única y el segmento de almacenamiento creados al principio del tutorial, sigue los pasos de la próxima sección.

Eliminar recursos manualmente

Si seguiste los pasos descritos en este tutorial de forma manual, puedes eliminar las instancias de Compute Engine y el segmento de Cloud Storage manualmente.

Eliminar la instancia de Compute Engine

Puedes eliminar una instancia de Compute Engine de la siguiente forma:

  1. En GCP Console, dirígete a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. Haz clic en la casilla de verificación junto ala instancia que deseas borrar.
  3. Haz clic en el botón Borrar en la parte superior de la página para borrar la instancia.

Eliminar el segmento de Cloud Storage

Para eliminar un segmento de Cloud Storage, sigue las instrucciones a continuación:

  1. En la GCP Console, dirígete al navegador de Cloud Storage.

    Ir al navegador de Cloud Storage

  2. Haz clic en la casilla de verificación junto al depósito que deseas borrar.
  3. Haz clic en el botón Borrar en la parte superior del depósito.

Siguientes pasos

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...