Cómo ejecutar la app de Bookshelf para Ruby en Compute Engine

Este instructivo muestra cómo ejecutar la app de Bookshelf para Ruby en Compute Engine. Sigue este instructivo para implementar una app web existente de Ruby 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 muestra de Bookshelf 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 podrían ser aptos para 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 Google Cloud Platform project.

    Go to the Manage resources page

  3. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a 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 Ruby 2.3 o posterior y Ruby on Rails. Además, necesitas Ruby Gems, que se incluye en Ruby.

Cómo inicializar Cloud Datastore

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

  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.

Cómo crear 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. Ingresa el siguiente comando en una ventana de la terminal:

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

    Donde:

    • [YOUR-BUCKET-NAME] es 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]

    Cómo clonar la app de muestra

    La app de muestra está disponible en GitHub en GoogleCloudPlatform/getting-started-ruby.

    1. Clona el repositorio.

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

      cd getting-started-ruby/7-compute-engine
      

    Cómo configurar la app

    1. Instala las dependencias.

      bundle install
      
    2. Copia los ejemplos proporcionados para crear archivos de configuración. Las rutas del archivo de configuración están en .gitignore y no se confirman en el control de versiones.

      cp config/database.example.yml config/database.yml
      cp config/settings.example.yml config/settings.yml
      
    3. Abre el archivo config/settings.yml para editarlo y reemplaza los siguientes valores.

      • @@PROJECT_ID@@ por el ID del proyecto.
      • @@BUCKET_NAME@@ por el nombre del depósito de almacenamiento que creaste en el paso anterior.
      • @@CLIENT_ID@@ por tu ID de cliente de OAuth.
      • @@CLIENT_SECRET@@ por tu secreto de cliente de OAuth.
    4. Guarda el archivo settings.yml y ciérralo.

    5. Abre config/database.yml para editarlo y reemplaza @@PROJECT_ID@@ por el ID de tu proyecto.

    6. Guarda el archivo database.yml y ciérralo.

    Cómo ejecutar la app en una computadora local

    1. Inicia un servidor web local.

      rails server
      
    2. En tu navegador web, ingresa http://localhost:3000.

      Para detener el servidor web local, presiona Control+C.

    Ejecuta el trabajador en una computadora local

    El trabajador usa el servicio de administración de filas Resque. Resque usa la tecnología de Redis, por lo que necesitas un servidor de Redis que se ejecute de manera local en el puerto 6379 para conectar el trabajador. Consulta la Guía de inicio rápido de Redis para comenzar.

    Una vez que Redis se ejecute, ingresa el siguiente comando en una ventana de comandos nueva:

    TERM_CHILD=1 QUEUE=* rake environment resque:work
    

    Ahora, agrega algunos libros a la app de Bookshelf. Si estás ejecutando la aplicación y la instancia de trabajador de manera local, puedes mirar cómo el trabajador actualiza la información de los libros en segundo plano.

    La interfaz de Resque está configurada para estar disponible en la siguiente dirección, la cual puedes usar para verificar el estado de tu trabajador:

    http://localhost:3000/resque
    

    Cómo implementar 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.

    Envía el código a un repositorio

    Puedes usar Cloud Source Repositories para crear fácilmente un repositorio de Git en tu proyecto y subir allí el código de tu app. Luego, durante el inicio, las 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 tu 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 Google Cloud Platform Console

      Crear repositorio

      o usa gcloud para crear uno.

      gcloud source repos create [YOUR_REPO]
      

      Donde:

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

    Estas son las secuencias de comandos de inicio incluidas en la app de muestra de Bookshelf:

    set -e
    
    # 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")
    REPO_NAME="[YOUR_REPO_NAME]"
    
    # Get the source code
    export HOME=/root
    git config --global credential.helper gcloud.sh
    # Change branch from master if not using master
    git clone https://source.developers.google.com/p/$PROJECTID/r/$REPO_NAME /opt/app -b master
    
    pushd /opt/app/7-compute-engine
    
    pushd config
    
    cp database.example.yml database.yml
    chmod go-rwx database.yml
    cp settings.example.yml settings.yml
    chmod go-rwx settings.yml
    
    # Add your GCP project ID here
    sed -i -e 's/@@PROJECT_ID@@/[YOUR_PROJECT_ID]/' settings.yml
    sed -i -e 's/@@PROJECT_ID@@/[YOUR_PROJECT_ID]/' database.yml
    
    # Add your cloud storage config here
    sed -i -e 's/@@BUCKET_NAME@@/[YOUR_BUCKET_NAME]/' settings.yml
    
    # Add your OAuth config here
    sed -i -e 's/@@CLIENT_ID@@/[YOUR_CLIENT_ID]/' settings.yml
    sed -i -e 's/@@CLIENT_SECRET@@/[YOUR_CLIENT_SECRET]/' settings.yml
    popd # config
    
    ./gce/configure.sh
    
    popd # /opt/app
    set -e
    
    curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
    cat >/etc/google-fluentd/config.d/railsapp.conf << EOF
    <source>
      type tail
      format none
      path /opt/app/7-compute-engine/log/*.log
      pos_file /var/tmp/fluentd.railsapp.pos
      read_from_head true
      tag railsapp
    </source>
    EOF
    service google-fluentd restart &
    
    # Install dependencies from apt
    apt-get update
    apt-get install -y git ruby ruby-dev build-essential libxml2-dev zlib1g-dev nginx libmysqlclient-dev libsqlite3-dev redis-server
    
    gem install bundler --no-ri --no-rdoc
    
    useradd -m railsapp
    chown -R railsapp:railsapp /opt/app
    
    mkdir /opt/gem
    chown -R railsapp:railsapp /opt/gem
    
    sudo -u railsapp -H bundle install --path /opt/gem
    sudo -u railsapp -H bundle exec rake assets:precompile
    
    systemctl enable redis-server.service
    systemctl start redis-server.service
    
    cat gce/default-nginx > /etc/nginx/sites-available/default
    systemctl restart nginx.service
    
    cat gce/railsapp.service > /lib/systemd/system/railsapp.service
    systemctl enable railsapp.service
    systemctl start railsapp.service
    
    cat gce/resqworker.service > /lib/systemd/system/resqworker.service
    systemctl enable resqworker.service
    systemctl start resqworker.service

    Esta secuencia de comandos de inicio ejecuta las siguientes tareas:

    1. Clona el código fuente de la app desde Cloud Source Repositories y establece tus archivos de configuración con tus secretos.

    2. Instala el agente de Stackdriver Logging y lo configura para que supervise los registros de la app. Esto significa que los registros configurados en el instructivo anterior se cargan en la sección de registro de Google Cloud Platform Console como si estuvieras utilizando App Engine.

    3. Instala y configura Ruby, Rails y NGINX.

    Cómo personalizar la secuencia de comandos de inicio

    La app de muestra proporciona una plantilla de secuencia de comandos de inicio que puedes modificar para que contenga tus secretos. Ten en cuenta que no debes registrar los secretos en el control de origen.

    1. Copia la secuencia de comandos de inicio en una que modifiques y no ingreses:

      cp gce/startup-script.sh gce/my-startup.sh
      
    2. Edita my-startup.sh. Agrega los secretos para la base de datos y Cloud Storage: los mismos que agregaste previamente a database.yml y settings.yml. Reemplaza los marcadores de posición [YOUR_* por tus valores.

      Por ejemplo:

      # Add your GCP project ID here
      sed -i -e 's/PROJECT_ID/your-project-id/' settings.yml
      sed -i -e 's/PROJECT_ID/your-project-id/' database.yml
      
      # Add your cloud storage config here
      sed -i -e 's/BUCKET_NAME/your-bucket-name/' settings.yml
      
      # Add your OAuth config here
      sed -i -e 's/CLIENT_ID/1234/' settings.yml
      sed -i -e 's/CLIENT_SECRET/1234/' settings.yml
      

    Crea y configura una instancia de Compute Engine

    1. Crea una instancia de Compute Engine. El siguiente comando crea una instancia nueva, le 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 \
          --machine-type=g1-small \
          --scopes logging-write,storage-rw,datastore,https://www.googleapis.com/auth/projecthosting \
          --metadata-from-file startup-script=gce/my-startup.sh \
          --zone us-central1-f \
          --tags http-server \
          --image-family ubuntu-1604-lts \
          --image-project ubuntu-os-cloud
      

      Windows

      gcloud compute instances create my-app-instance ^
          --machine-type=g1-small ^
          --scopes logging-write,storage-rw,datastore,https://www.googleapis.com/auth/projecthosting ^
          --metadata-from-file startup-script=gce/my-startup.sh ^
          --zone us-central1-f ^
          --tags http-server ^
          --image-family ubuntu-1604-lts ^
          --image-project ubuntu-os-cloud
      

    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-80 \
          --allow tcp:80 \
          --source-ranges 0.0.0.0/0 \
          --target-tags http-server \
          --description "Allow port 80 access to http-server"
      

      Windows

      gcloud compute firewall-rules create default-allow-http-80 ^
          --allow tcp:80 ^
          --source-ranges 0.0.0.0/0 ^
          --target-tags http-server ^
          --description "Allow port 80 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],

      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 conectarse a ella con ssh, ve a Compute > Compute Engine.

    Para ver todos los registros generados por los recursos de Compute Engine, ve a Supervisión > Registros. 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 de forma automática instancias nuevas de tu app cuando se requiera y apagar instancias cuando la demanda sea baja. 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 siguientes pasos de implementación. La secuencia de comandos denominada 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 siguientes pasos tú mismo o ejecutar gce/deploy.sh desde el directorio gce.

    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 my-app-tmpl \
          --machine-type=g1-small \
          --scopes logging-write,storage-rw,datastore,https://www.googleapis.com/auth/projecthosting \
          --metadata-from-file startup-script=gce/my-startup.sh \
          --image-family ubuntu-1604-lts \
          --image-project ubuntu-os-cloud \
          --tags http-server
      
    2. Crea un grupo de instancias.

      gcloud compute instance-groups managed create my-app-group \
          --base-instance-name my-app \
          --size 2 \
          --template my-app-tmpl \
          --zone us-central1-f
      

      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 bookshelf-health-check \
          --request-path / \
          --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 my-app-group \
          --named-ports http:8080 \
          --zone us-central1-f
      
    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 qué verificación de estado se debe usar.

      gcloud compute backend-services create my-app-service \
          --http-health-check bookshelf-health-check
      
    4. Agrega el servicio de backend.

      gcloud compute backend-services add-backend my-app-service \
          --group my-app-group \
          --zone us-central1-f
      
    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 esta muestra, 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 my-app-service-map \
            --default-service my-app-service
        
      2. Crea el proxy.

        gcloud compute target-http-proxies create my-app-service-proxy \
            --url-map my-app-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 my-app-service-http-rule \
          --global \
          --target-http-proxy my-app-service-proxy \
          --port-range 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 my-app-group \
          --max-num-replicas 10 \
          --target-load-balancing-utilization 0.5 \
          --zone us-central1-f
      

      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%, se quitan estas instancias.

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

    Visualiza tu aplicación

    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 ahora se ejecuta 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 > Grupos de instancias.

    Para administrar la configuración del balanceo de cargas, incluidos los mapas de URL y los servicios de backend, usa la sección Servicios de red > Balanceo de cargas.

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 teardown

Si ejecutaste la secuencia de comandos deploy.sh, ejecuta teardown.sh para borrar todos los recursos que creó 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, haz lo siguiente:

  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 tu instancia única 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 el 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 sirvió esta página? Envíanos tu opinión: