Cómo ejecutar Bookshelf de PHP en Compute Engine

Este instructivo muestra cómo ejecutar la app de Bookshelf de PHP en Google Compute Engine. Sigue este instructivo para implementar una app web existente de PHP 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

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. 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 PHP y Composer.

Cómo inicializar Cloud Datastore

La app de Bookshelf utiliza Cloud Datastore para almacenar los libros. Sigue estos pasos 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.

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

    Cómo clonar la app de muestra

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

    1. Clona el repositorio.

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

      cd getting-started-php/optional-compute-engine
      

    Cómo configurar la app

    1. Copia el archivo settings.yml.dist:

      cp config/settings.yml.dist config/settings.yml
      
    2. Abre el archivo config/settings.yml para editarlo.

    3. Reemplaza YOUR_PROJECT_ID por el ID de tu proyecto.

    4. Configura el valor de bookshelf_backend en datastore.

    5. Guarda el archivo settings.yml y ciérralo.

    Cómo ejecutar la app en una computadora local

    1. Instala las dependencias:

      composer install
      
    2. Inicia un servidor web local:

      php -S localhost:8000 -t web
      
    3. En el navegador web, ingresa la siguiente dirección:

      http://localhost:8000

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

    Cómo implementar en una instancia única

    Implementación de instancia única

    En esta sección, se explica cómo ejecutar una instancia única de tu app en Compute Engine.

    Envía tu 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 trabajas con 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]
      

      Leyenda:

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

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

    La secuencia de comandos de inicio completa se define en gce/startup-script.sh.

    # Install PHP and dependencies from apt
    apt-get update
    apt-get install -y git nginx mongodb-clients php5 php5-fpm php5-mysql php5-dev php-pear pkg-config
    pecl install mongodb
    
    # Enable the MongoDB PHP extension
    echo "extension=mongodb.so" >> /etc/php5/mods-available/mongodb.ini
    php5enmod mongodb
    
    # Install Composer
    curl -sS https://getcomposer.org/installer | \
        /usr/bin/php -- \
        --install-dir=/usr/local/bin \
        --filename=composer
    
    # Fetch the project ID from the Metadata server
    PROJECTID=$(curl -s "http://metadata.google.internal/computeMetadata/v1/project/project-id" -H "Metadata-Flavor: Google")
    
    # Get the application source code
    git config --global credential.helper gcloud.sh
    git clone https://source.developers.google.com/p/$PROJECTID /opt/src -b master
    ln -s /opt/src/optional-compute-engine /opt/app
    
    # Run Composer
    composer install -d /opt/app --no-ansi --no-progress

    Primero, la secuencia de comandos instala y configura las bibliotecas de sistemas que se necesitan para esta app, incluidas PHP, la extensión PHP de MongoDB, Composer y NGINX. A continuación, clona el código fuente de la app desde Cloud Source Repositories y, luego, instala las dependencias.

    # Fetch the application config file from the Metadata server and add it to the project
    curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/project-config" \
      -H "Metadata-Flavor: Google" >> /opt/app/config/settings.yml

    La configuración YAML de la app, incluidos los secretos del proyecto, se obtiene del servidor de los metadatos de Compute. Este archivo se transfiere al servidor de metadatos cuando se crea la instancia de procesamiento.

    # Disable the default NGINX configuration
    rm /etc/nginx/sites-enabled/default
    
    # Enable our NGINX configuration
    cp /opt/app/gce/nginx/bookshelf.conf /etc/nginx/sites-available/bookshelf.conf
    ln -s /etc/nginx/sites-available/bookshelf.conf /etc/nginx/sites-enabled/bookshelf.conf
    cp /opt/app/gce/nginx/fastcgi_params /etc/nginx/fastcgi_params
    
    # Start NGINX
    systemctl restart nginx.service

    La configuración de NGINX para esta app se instala mediante gce/nginx/bookshelf.conf. Luego, se inicia NGINX.

    # Install Fluentd
    curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
    
    # Enable our Fluentd configuration
    cp /opt/app/gce/fluentd/bookshelf.conf /etc/google-fluentd/config.d/bookshelf.conf
    
    # Start Fluentd
    service google-fluentd restart &

    Por último, la secuencia de comandos instala y configura el agente de Logging. Esto garantiza que el registro que se agregó antes en este instructivo funcione correctamente.

    Cómo crear y configurar 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 \
          --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
      

      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,

      En este comando, [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 el escalador automático de Compute Engine, Compute Engine puede crear instancias nuevas de tu app cuando se requieran y desactivar instancias cuando la demanda sea baja de manera 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 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.

    Cómo 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 my-app-tmpl \
          --machine-type=g1-small \
          --scopes logging-write,storage-ro,https://www.googleapis.com/auth/projecthosting \
          --metadata-from-file startup-script=gce_deployment/startup-script.sh,project-config=config/settings.yml \
          --image ubuntu-15-04 \
          --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.

    Cómo crear un balanceador de cargas

    Una instancia individual sirve para hacer pruebas o depuraciones, pero cuando se trata de entregar 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
      
    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 ah-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 este ejemplo, 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 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 entre 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%, estas instancias se quitan.

    2. Crea una regla de firewall.

      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"
      

    3. Revisa el progreso hasta que al menos una de las 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 la 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 de desmontaje

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

Si seguiste los pasos de este instructivo de manera manual, puedes 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 borrarlo.

  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 borrar el balanceador de cargas y los recursos asociados a este.

Borra el grupo de instancias administrado de Compute Engine

Sigue estos pasos 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

Sigue estos pasos 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.

¿Qué sigue?

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