Ejecutar Bookshelf de Java en Compute Engine

En este tutorial, se explica cómo ejecutar la aplicación Bookshelf de Java en Google Compute Engine. Sigue las instrucciones de este tutorial para desplegar una aplicación web de Java 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. 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. 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 Java 8 y Maven.

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 a través de GoogleCloudPlatform/getting-started-java.

  1. Clona el repositorio:

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

    cd getting-started-java/bookshelf/6-gce
    

Configurar la aplicación

  1. Abre makeBookshelf para editarlo.
  2. Establece la variable BUCKET con el nombre del segmento que creaste anteriormente.
  3. También puedes cambiar ZONE=us-central1-f a una zona diferente.
  4. Haz que la secuencia de comandos sea ejecutable: chmod +x makeBookshelf.
  5. Abre pom.xml para editarlo.
  6. Establece la propiedad bookshelf.bucket con el nombre del segmento.
  7. Guarda y cierra ambos archivos.

    Ejecutar la aplicación en el ordenador local

    1. Inicia un servidor web local:

      mvn -Plocal clean jetty:run-exploded -DprojectID=[YOUR-PROJECT-ID]
      

      donde [YOUR-PROJECT-ID] es el ID del proyecto.

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

    Introduce este comando para crear una instancia de Compute Engine y enviar la aplicación a la instancia:

    ./makeBookshelf gce
    

    El comando realiza lo siguiente:

    • Crea el proyecto y crea un archivo WAR de Java.
    • Carga el archivo WAR y algunas secuencias de comandos en el segmento de Cloud Storage que creaste anteriormente para almacenar imágenes.
    • Crea una instancia de Compute Engine y te permite acceder a Cloud Logging, Cloud Storage y Cloud Datastore.
    • Transfiere los metadatos sobre el segmento de Cloud Storage.
    • Especifica la secuencia de comandos de inicio.
    mvn clean package
    
    gsutil cp -r target/${WAR} gce/base gs://${BUCKET}/gce/
    
    gcloud compute firewall-rules create allow-http-bookshelf \
      --allow tcp:80 \
      --source-ranges 0.0.0.0/0 \
      --target-tags ${TAGS} \
      --description "Allow port 80 access to instances tagged with ${TAGS}"
    
    gcloud compute instances create my-app-instance \
      --machine-type=${MACHINE_TYPE} \
      --scopes=${SCOPES} \
      --metadata-from-file startup-script=${STARTUP_SCRIPT} \
      --zone=${ZONE} \
      --tags=${TAGS} \
      --image-family=${IMAGE_FAMILY} \
      --image-project=${IMAGE_PROJECT} \
      --metadata BUCKET=${BUCKET}

    La secuencia de comandos makeBookshelf define distintas variables:

    ZONE=us-central1-f
    
    GROUP=frontend-group
    TEMPLATE=$GROUP-tmpl
    MACHINE_TYPE=g1-small
    IMAGE_FAMILY=debian-8
    IMAGE_PROJECT=debian-cloud
    STARTUP_SCRIPT=gce/startup-script.sh
    SCOPES="datastore,userinfo-email,logging-write,storage-full,cloud-platform"
    TAGS=http-server
    
    MIN_INSTANCES=1
    MAX_INSTANCES=10
    TARGET_UTILIZATION=0.6
    
    SERVICE=frontend-web-service
    WAR=bookshelf-1.0-SNAPSHOT.war

    La instancia tardará aproximadamente cinco minutos en ejecutar la secuencia de comandos de inicio. Puedes introducir este comando para verificar el progreso de la instancia:

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

    Una vez que se completa la secuencia de comandos de inicio, puedes verificar los registros de inicio en la nueva instancia en /var/logs/daemon.log.

    El nombre de la instancia es my-app-instance. Puedes ingresar este comando para obtener la dirección IP externa de la instancia:

    gcloud compute instances list
    

    Si quieres ver la aplicación en ejecución, introduce la siguiente URL en el navegador:

    http://[YOUR_INSTANCE_IP]
    

    Si quieres eliminar la instancia, introduce el siguiente comando:

    ./makeBookshelf down
    

    El siguiente comando hace lo mismo:

    gcloud compute instances delete my-app-instance
    

    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í se presenta una secuencia de comandos de inicio que realiza las siguientes tareas:

    • Instala Java 8 y lo convierte en predeterminado.

    • Instala y configura Jetty.

    • Copia el archivo WAR de Java del segmento de Cloud Storage a las aplicaciones webapps de Jetty y lo renombra como root.war. Esto lo convierte en el servlet raíz, por lo tanto, no necesita nombrarse en la URL.

    • Instala el agente de Google Cloud Logging y lo configura para supervisar los registros de la aplicación. Esto significa que el almacenamiento de registros configurado en los pasos anteriores de este tutorial se cargará como si estuviera utilizando el entorno flexible de App Engine.

    set -e
    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")
    BUCKET=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/BUCKET" -H "Metadata-Flavor: Google")
    
    echo "Project ID: ${PROJECTID}  Bucket: ${BUCKET}"
    
    # get our file(s)
    gsutil cp "gs://${BUCKET}/gce/"** .
    
    # Install dependencies from apt
    apt-get update
    apt-get install -t jessie-backports -yq openjdk-8-jdk
    
    # Make Java8 the default
    update-alternatives --set java /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java
    
    # Jetty Setup
    mkdir -p /opt/jetty/temp
    mkdir -p /var/log/jetty
    
    # Get Jetty
    curl -L https://repo1.maven.org/maven2/org/eclipse/jetty/jetty-distribution/9.3.8.v20160314/jetty-distribution-9.3.8.v20160314.tar.gz -o jetty9.tgz
    tar xf jetty9.tgz  --strip-components=1 -C /opt/jetty
    
    # Add a Jetty User
    useradd --user-group --shell /bin/false --home-dir /opt/jetty/temp jetty
    
    cd /opt/jetty
    # Add running as "jetty"
    java -jar /opt/jetty/start.jar --add-to-startd=setuid
    cd /
    
    # very important - by renaming the war to root.war, it will run as the root servlet.
    mv bookshelf-1.0-SNAPSHOT.war /opt/jetty/webapps/root.war
    
    # Make sure "jetty" owns everything.
    chown --recursive jetty /opt/jetty
    
    # Configure the default paths for the Jetty service
    cp /opt/jetty/bin/jetty.sh /etc/init.d/jetty
    echo "JETTY_HOME=/opt/jetty" > /etc/default/jetty
    {
      echo "JETTY_BASE=/opt/jetty"
      echo "TMPDIR=/opt/jetty/temp"
      echo "JAVA_OPTIONS=-Djetty.http.port=80"
      echo "JETTY_LOGS=/var/log/jetty"
    } >> /etc/default/jetty
    
    # -Dorg.eclipse.jetty.util.log.class=org.eclipse.jetty.util.log.JavaUtilLog
    
    # Reload daemon to pick up new service
    systemctl daemon-reload
    
    # 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 &
    
    service jetty start
    service jetty check
    
    echo "Startup Complete"

    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:

      ./makeBookshelf gce-many
      

    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 80

    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:

    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

    4. Agrega el siguiente servicio de backend:

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

    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 \
        --port-range 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:

      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"
      

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

Eliminar el segmento de Cloud Storage

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

  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.

Siguientes pasos

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