Ejecución de Bookshelf en Node.js en Compute Engine

En este instructivo se muestra cómo ejecutar la aplicación Bookshelf en Node.js en Google Compute Engine. Sigue este instructivo para implementar una aplicación web en Node.js existente en Compute Engine. Debes revisar la documentación de la aplicación 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

En este instructivo, se usan componentes facturables de Google Cloud Platform (GCP), incluidos los siguientes:

  • 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 ser aptos para una prueba gratuita.

Antes de comenzar

  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. 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. Realiza la instalación y la inicialización del SDK de Cloud.
  6. Instala Node.js y npm mediante el instalador oficial.

Inicializar Cloud Datastore

La aplicación Bookshelf usa 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 aplicación de Bookshelf está lista para crear entidades en Cloud Datastore.

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

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

    Donde:

    • [YOUR-BUCKET-NAME] representa el nombre de tu depósito de Cloud Storage.
  2. Para ver las imágenes que se subieron en la aplicación 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]

    Crear un ID de cliente de aplicación web

    Mediante un ID de cliente de aplicación web, tu aplicación puede autorizar usuarios y acceder a las API de Google en nombre de ellos.

    1. En Google Cloud Platform Console, ve a Credenciales.

      Credenciales.

    2. Haz clic en la pantalla de consentimiento de OAuth. Ingresa Node.js Bookshelf App como el nombre del producto.

    3. En Dominios autorizados, agrega el nombre de tu aplicación de App Engine como [YOUR_PROJECT_ID].appspot.com. Reemplaza [YOUR_PROJECT_ID] por el ID del proyecto de GCP.

    4. Llena todos los campos opcionales de relevancia. Haz clic en Guardar.

    5. Haz clic en Crear credenciales > ID de cliente de OAuth.

    6. En la lista desplegable Tipo de aplicación, haz clic en Aplicación web.

    7. En el campo Nombre, ingresa Node.js Bookshelf Client.

    8. En el campo URI de redireccionamiento autorizado, ingresa las siguientes URL, una a la vez.

      http://localhost:8080/auth/google/callback
      http://[YOUR_PROJECT_ID].appspot.com/auth/google/callback
      https://[YOUR_PROJECT_ID].appspot.com/auth/google/callback

    9. Haz clic en Crear.

    10. Copia el ID de cliente y el secreto de cliente y guárdalos para después.

    Clonar la aplicación de muestra

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

    1. Clona el repositorio.

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

      cd nodejs-getting-started/7-gce
      

    Configurar la aplicación

    En el directorio de muestra, crea un archivo config.json que contenga lo siguiente:

    {
      "GCLOUD_PROJECT": "[YOUR_PROJECT_ID]",
      "CLOUD_BUCKET": "[YOUR_CLOUD_BUCKET]",
      "DATA_BACKEND": "datastore",
      "OAUTH2_CLIENT_ID": "[YOUR_OAUTH2_CLIENT_ID]",
      "OAUTH2_CLIENT_SECRET": "[YOUR_OAUTH2_CLIENT_SECRET]",
      "OAUTH2_CALLBACK": "http://localhost:8080/auth/google/callback"
    }
    

    donde:

    • [YOUR_PROJECT_ID] es el ID de tu proyecto.
    • [YOUR_CLOUD_BUCKET] es el nombre de tu depósito de Cloud Storage.
    • [YOUR_OAUTH2_CLIENT_ID] es el ID de cliente de la aplicación que creaste anteriormente.
    • [YOUR_OAUTH2_CLIENT_SECRET] es el secreto de cliente que creaste anteriormente.

    Ejecución de la app en tu computadora local

    1. Instale las dependencias:

      npm install
      
    2. Ejecuta la app:

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

      http://localhost:8080

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

    Implementar en una instancia única

    Implementación de instancia única

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

    Enviar tu código a un repositorio

    Usa Cloud Source Repositories a fin de crear fácilmente un repositorio 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 aplicación desde el repositorio. Esto es muy útil, ya que para actualizar la aplicación no será necesario que configures imágenes o instancias nuevas; solo debes reiniciar una instancia existente o crear una nueva.

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

    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 de tu proyecto.
      • [YOUR_REPO] es el nombre del repositorio que acabas de crear.
    2. Envía el código de tu aplicación 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
      

    Usar 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")
    REPOSITORY="[YOUR-REPOSITORY]"
    
    # Install logging monitor. The monitor will automatically pick up 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 ca-certificates git build-essential supervisor
    
    # Install nodejs
    mkdir /opt/nodejs
    curl https://nodejs.org/dist/v8.12.0/node-v8.12.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
    ln -s /opt/nodejs/bin/node /usr/bin/node
    ln -s /opt/nodejs/bin/npm /usr/bin/npm
    
    # Get the application 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/${REPOSITORY} /opt/app
    
    # Install app dependencies
    cd /opt/app/7-gce
    npm install
    
    # Create a nodeapp user. The application will run as this user.
    useradd -m -d /home/nodeapp nodeapp
    chown -R nodeapp:nodeapp /opt/app
    
    # Configure supervisor to run the node app.
    cat >/etc/supervisor/conf.d/node-app.conf << EOF
    [program:nodeapp]
    directory=/opt/app/7-gce
    command=npm start
    autostart=true
    autorestart=true
    user=nodeapp
    environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production"
    stdout_logfile=syslog
    stderr_logfile=syslog
    EOF
    
    supervisorctl reread
    supervisorctl update
    
    # Application should now be running under supervisor

    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 Node.js y Supervisor. Supervisor ejecuta la aplicación como un daemon.

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

    • Configura Supervisor para ejecutar la aplicación. 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 aplicación a syslog para que el agente de Logging los recopile.

    Crear y configurar 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 o 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 app-location=$BOOKSHELF_DEPLOY_LOCATION \
          --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
      

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

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

      Linux o 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 aplicación en ejecución, ve a 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 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 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. Compute Engine puede crear instancias nuevas de tu aplicación automáticamente cuando se requiera y apagar instancias cuando la demanda sea baja, mediante un grupo de instancias administrado y su escalador automático. Para distribuir el tráfico a las instancias, puedes configurar un balanceador de cargas HTTP en un grupo de instancias administrado.

    Secuencia de comandos de implementación

    La aplicación 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 aplicación 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.

    Crear 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 $IMAGE \
        --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.

    Crear 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 entregar 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 servicio define a qué grupo de instancias se debe dirigir el tráfico y cuál verificación de estado se debe usar.

      gcloud compute backend-services create $SERVICE \
        --http-health-checks ah-health-check \
        --port 8080
      gcloud compute http-health-checks create ah-health-check \
        --request-path /_ah/health \
        --port 8080
    4. Agrega el servicio de backend.

      gcloud compute backend-services add-backend $SERVICE \
        --instance-group $GROUP \
        --zone $ZONE
    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 entrega 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 \
        --port-range 80

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

      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"

    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
      

    Ver 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 aplicación con balanceador de cargas y ajuste de escala automático se ejecuta ahora en Google Compute Engine.

    Administrar y supervisar 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.

Limpiar

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

Ejecutar la secuencia de comandos "teardown"

Si ejecutaste la secuencia de comandos deploy.sh, ejecuta la secuencia de comandos teardown.sh para borrar 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.

Borrar los recursos de forma manual

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

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

Borrar el grupo de instancias administrado de Compute Engine

Para borrar un grupo de instancias de Compute Engine:

  1. En la GCP Console, dirígete a la página de Grupos de instancias.

    Ir a la página de Grupos de instancias

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

Borrar la instancia única de Compute Engine

Para borrar una instancia de Compute Engine:

  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.

Borrar el depósito de Cloud Storage

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

  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.

Pasos siguientes

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…