Cómo ejecutar Bookshelf en Python en Compute Engine

Este instructivo muestra cómo ejecutar la app de Bookshelf en Python en Compute Engine. Sigue este instructivo para implementar una app web existente de Python en Compute Engine. Debes revisar la documentación de la app de Bookshelf como parte del instructivo para el entorno estándar de App Engine.

Objetivos

  • Implementar la app de Bookshelf de muestra en una instancia única de Compute Engine.
  • Escalar la app de manera horizontal mediante un grupo de instancias administradas.
  • Procesar el tráfico mediante el balanceo de cargas HTTP.
  • Responder a los cambios en el tráfico mediante el ajuste de escala automático.

Costos

Este instructivo utiliza componentes facturables de Google Cloud Platform (GCP), incluidos:

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

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de GCP pueden optar a una prueba gratuita.

Antes de comenzar

  1. Sign in to your Google Account.

    If you don't already have one, sign up for a new account.

  2. Select or create a GCP project.

    Go to the Project selector page

  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. Install and initialize the Cloud SDK.
  6. Instala Python, pip y virtualenv en tu sistema. Para conocer las instrucciones, consulta Configurar un entorno de programación en Python para Google Cloud Platform.

Inicializa Cloud Datastore

La app de Bookshelf utiliza Cloud Datastore para almacenar los libros. Para inicializar Cloud Datastore en tu proyecto por primera vez:

  1. Abre Cloud Datastore en GCP Console.

  2. Selecciona una región para tu almacén de datos y haz clic en Continuar. Cuando llegues a la página Crear una entidad, cierra la ventana. La app de Bookshelf está lista para crear entidades en Cloud Datastore.

Crea un depósito de Cloud Storage

Las instrucciones siguientes muestran cómo crear un depósito de Cloud Storage. Los depósitos son los contenedores básicos que conservan tus datos en Cloud Storage.

  1. En una ventana de terminal, ingresa el siguiente comando:

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

    Leyenda:

    • [YOUR-BUCKET-NAME] representa el nombre de tu depósito de Cloud Storage.
  2. Para ver las imágenes que se subieron en la app de Bookshelf, configura la Lista de control de acceso (LCA) predeterminada del depósito como public-read.

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

    Clona la app de muestra

    La app 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
      

    Configura la app

    1. Abre config.py para editarlo.

    2. Configura el valor de PROJECT_ID como el ID de tu proyecto.

    3. Configura el valor CLOUD_STORAGE_BUCKET con el nombre de tu depósito de Cloud Storage.

    4. Guarda el archivo config.py y ciérralo.

    Ejecuta la app en tu computadora local

    1. Crea un entorno aislado de Python y, luego, instala las dependencias:

      Linux/macOS

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

      Windows

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

    2. Utiliza Honcho de forma local para ejecutar tanto la aplicación como el trabajador de tareas. Obtén más información sobre cómo utilizar Honcho en la sección Cloud Pub/Sub del instructivo.

      honcho start -f ./procfile worker bookshelf

    3. En el navegador web, ingresa la siguiente dirección:

      http://localhost:8080

    Para detener ambas tareas locales, presiona Control+C.

    Implementa la app en una instancia única

    Implementación de instancia única

    Esta sección te explica cómo ejecutar una instancia única de tu app en Compute Engine.

    Cómo enviar tu código a un repositorio

    Usa Cloud Source Repositories para crear fácilmente un repositorio de Git en tu proyecto y para subir allí el código de tu aplicación. Luego, durante el inicio, tus instancias podrán obtener la versión más reciente del código de tu app desde el repositorio. Esto es muy útil, ya que para actualizar la app no será necesario que configures imágenes o instancias nuevas; solo debes reiniciar una instancia existente o crear una nueva.

    Si es la primera vez que utilizas Git, usa git config --global para configurar tu identidad.

    1. Crea un repositorio en la sección de Google Cloud Platform Console

      Crear repositorio

      o usa gcloud para crear uno.

      gcloud source repos create [YOUR_REPO]
      

      Leyenda:

      • [YOUR_PROJECT_ID] es el ID del proyecto.
      • [YOUR_REPO] es el nombre del repositorio que acabas de crear.
    2. Envía el código de tu app al repositorio del proyecto.

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

    Usa una secuencia de comandos de inicio para inicializar una instancia

    Ahora que las instancias de Compute Engine pueden acceder a tu código, necesitas una manera de indicarle a tu instancia que descargue y ejecute tu código. Una instancia puede tener una secuencia de comandos de inicio que se ejecuta cada vez que la instancia se inicia o se reinicia.

    Esta es la secuencia de comandos de inicio incluida en la app de Bookshelf de muestra:

    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 -p python3 /opt/app/7-gce/env
    source /opt/app/7-gce/env/bin/activate
    /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/honcho start -f ./procfile worker bookshelf
    autostart=true
    autorestart=true
    user=pythonapp
    # Environment variables ensure that the application runs inside of the
    # configured virtualenv.
    environment=VIRTUAL_ENV="/opt/app/7-gce/env",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, reemplaza [YOUR_REPO_NAME] por el nombre de tu repositorio.

    La secuencia de comandos de inicio realiza las siguientes tareas:

    • Instala el agente de Stackdriver Logging. Este agente recopila registros de syslog automáticamente.

    • Instala Python y Supervisor. Supervisor ejecuta la app como un daemon.

    • Clona el código fuente de la app desde Cloud Source Repositories y, luego, instala dependencias.

    • Configura Supervisor para ejecutar la app. Supervisor se asegura de que la aplicación se reinicie si se cierra de manera inesperada o si otro proceso o un administrador la obliga a cerrarse. Además, envía el stdout y el stderr de la app a syslog para que el agente de Logging los recopile.

    Crea y configura una instancia de Compute Engine

    1. Crea una instancia de Compute Engine. El siguiente comando crea una instancia nueva, permite acceder a los servicios de GCP y ejecuta tu secuencia de comandos de inicio. El nombre de la instancia es my-app-instance.

      Linux/macOS

      gcloud compute instances create my-app-instance \
          --image-family=debian-9 \
          --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-9 ^
          --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
      

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

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

      Si se completó la secuencia de comandos de inicio, se muestra Finished running startup script cerca del final del resultado del comando.

    3. Crea una regla de firewall para permitir el tráfico hacia tu instancia.

      Linux/macOS

      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. Para ver la app en ejecución, ve a http://[YOUR_INSTANCE_IP]:8080,

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

    Administra y supervisa una instancia

    Puedes usar Google Cloud Platform Console para supervisar y administrar tu instancia.

    Para ver la instancia en ejecución y conectarte a ella con ssh, ve a Compute > Compute Engine.

    Para ver todos los registros generados por tus recursos de Compute Engine, ve a Monitoring > Logs. Stackdriver Logging se configura automáticamente para recopilar los registros de diversos servicios comunes, incluido syslog.

    Escalamiento horizontal con varias instancias

    Implementación de varias instancias con instancias administradas

    Compute Engine puede escalar de manera horizontal fácilmente. Si se utiliza un grupo de instancias administrado y su escalador automático, Compute Engine puede crear instancias nuevas de tu app cuando se requiera y apagar instancias cuando la demanda sea baja de forma automática. Puedes configurar un balanceador de cargas HTTP para distribuir el tráfico a las instancias en un grupo de instancias administrado.

    Secuencia de comandos de implementación

    La app de muestra incluye una secuencia de comandos que automatiza los pasos de implementación siguientes. La secuencia de comandos llamada deploy.sh implementa los recursos para una app completa, con ajuste de escala automático y balanceador de cargas, como se describe en Escalamiento horizontal con varias instancias.

    Puedes ejecutar cada uno de los pasos siguientes o ejecutar gce/deploy.sh desde el directorio gce.

    Los valores predeterminados para las variables de entorno, incluidas $IMAGE_FAMILY, $IMAGE_PROJECT, $MACHINE_TYPE y $SCOPES, se pueden revisar en la sección de inicialización de gce/deploy.sh.

    Crea un grupo de instancias administrado

    Un grupo de instancias administrado es un grupo de instancias homogéneas basado en la misma plantilla de instancias. Una plantilla de instancias define la configuración de tu instancia, incluida la imagen de origen, el tamaño del disco, los alcances y los metadatos, entre ellos las secuencias de comandos 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. 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 la cantidad de instancias en el grupo. Una vez que todas las instancias terminen de ejecutar sus secuencias de comandos de inicio, se puede acceder a las instancias de manera individual a través de sus direcciones IP externas y el puerto 8080. Para buscar las direcciones IP externas de las instancias, ingresa gcloud compute instances list. Las instancias administradas tienen nombres que comienzan con el mismo prefijo, my-app, el cual especificaste en el parámetro --base-instance-name.

    Crea un balanceador de cargas

    Una instancia individual sirve para hacer pruebas o depuraciones, pero, cuando se trata de procesar el tráfico web, es mejor usar un balanceador de cargas que lo dirija automáticamente a las instancias disponibles. Sigue estos pasos para crear un balanceador de cargas.

    1. Crea una verificación de estado. El balanceador de cargas usa una verificación de estado para determinar qué instancias pueden procesar el 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 cargas HTTP busca el servicio http para saber a qué puerto debe dirigir el tráfico. En tu grupo de instancias existente, asigna al puerto 8080 el nombre http.

      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 carga balanceada. Este define a qué grupo de instancias se debe dirigir el tráfico y la verificación de estado que se debe usar.

      gcloud compute backend-services create $SERVICE \
        --http-health-checks ah-health-check \
        --global
    4. Agrega el servicio de backend.

      gcloud compute backend-services add-backend $SERVICE \
        --instance-group $GROUP \
        --instance-group-zone $ZONE \
        --global
    5. Crea un proxy y un mapa de URL. El mapa de URL define las URL que deben dirigirse a servicios de backend específicos. En este ejemplo, un servicio de backend procesa todo el tráfico. Si quieres balancear la carga de solicitudes entre varias regiones o grupos, puedes crear varios servicios de backend. Un proxy recibe el tráfico y lo desvía a los servicios de backend mediante mapas de URL.

      1. Crea el mapa de URL.

        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 conecta un puerto y una dirección IP pública a un proxy.

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

    Configura el escalador automático

    El balanceador de cargas garantiza que el tráfico se distribuya a través de todas las instancias en buen estado. ¿Pero qué sucede si hay demasiado tráfico y tus instancias no pueden controlarlo? Podrías agregar más instancias de forma manual. Sin embargo, una mejor solución es configurar un escalador automático de Compute Engine para que cree y borre instancias automáticamente como respuesta a las exigencias de tráfico.

    1. Crea un escalador automático.

      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 un escalador automático en el grupo de instancias administrado que escala automáticamente hasta un máximo de 10 instancias. Cuando el balanceador de cargas supera el 50% de uso, se crean instancias nuevas. Si el uso es inferior al 50%, estas instancias se quitan.

    2. Crea una regla de firewall.

      # 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. Revisa el progreso hasta que al menos una de tus instancias muestre el estado HEALTHY.

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

    Cómo ver tu app

    1. Obtén la dirección IP de reenvío del balanceador de cargas.

      gcloud compute forwarding-rules list --global
      

      La dirección IP de tus reglas de reenvío está en la columna IP_ADDRESS.

    2. En un navegador, ingresa la dirección IP de la lista. Tu app con balanceador de cargas y ajuste de escala automático se ejecuta ahora en Compute Engine.

    Administra y supervisa tu implementación

    Administrar varias instancias es tan fácil como administrar una sola. Usa GCP Console para supervisar el balanceo de cargas, el ajuste de escala automático y tu grupo de instancias administrado.

    Para administrar tu grupo de instancias y la configuración del ajuste de escala automático, usa la sección Compute Engine > Instance groups.

    Para administrar la configuración del balanceo de cargas, incluidos los mapas de URL y los servicios de backend, usa la sección Network services > Load balancing.

Cómo realizar una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Ejecuta la secuencia de comandos de desmontaje

Si ejecutaste la secuencia de comandos deploy.sh, ejecuta la secuencia de comandos teardown.sh para quitar todos los recursos que creó la secuencia de comandos deploy.sh. Esto devuelve tu proyecto al estado previo a la ejecución de la secuencia de comandos deploy.sh y ayuda a evitar que se apliquen más cargos. Sigue las instrucciones de la sección siguiente para quitar la instancia única y el depósito de almacenamiento que creaste al inicio del instructivo.

Borra recursos de forma manual

Si seguiste los pasos de este instructivo de forma manual, podrás borrar los recursos en la nube que hayas creado de la misma manera.

Borra el balanceador de cargas

  1. En GCP Console, ve a la página Balanceo de cargas.

    Ir a la página Balanceo de cargas

  2. Haz clic en la casilla de verificación junto al balanceador de cargas que deseas borrar.

  3. Haz clic en el botón Borrar en la parte superior de la página para eliminar el balanceador de cargas.

  4. En el cuadro de diálogo Borrar balanceador de cargas, selecciona el servicio de backend y los recursos de verificación de estado asociados.

  5. Haz clic en el botón Borrar balanceador de cargas para eliminar el balanceador de cargas y los recursos asociados a este.

Borra el grupo de instancias administradas de Compute Engine

Para borrar un grupo de instancias de Compute Engine:

  1. In the GCP Console, go to the Instance groups page.

    Go to the Instance groups page

  2. Click the checkbox for the instance group you want to delete.
  3. Click Delete to delete the instance group.

Borra la única instancia de Compute Engine

Para borrar una instancia de Compute Engine:

  1. In the GCP Console, go to the VM Instances page.

    Go to the VM Instances page

  2. Click the checkbox for the instance you want to delete.
  3. Click Delete to delete the instance.

Borra tu depósito de Cloud Storage

Para borrar un depósito de Cloud Storage, haz lo siguiente:

  1. In the GCP Console, go to the Cloud Storage Browser page.

    Go to the Cloud Storage Browser page

  2. Click the checkbox for the bucket you want to delete.
  3. Click Delete to delete the bucket.

Pasos siguientes

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

Enviar comentarios sobre...