Ejecutar Bookshelf para PHP en Compute Engine

En este tutorial, se muestra cómo ejecutar la aplicación Bookshelf para PHP en Google Compute Engine. Sigue las instrucciones para desplegar una aplicación web de PHP en Compute Engine. No es necesario estar familiarizado con la aplicación Bookshelf para seguir las indicaciones de este tutorial, pero si quieres obtener más información al respecto, consulta el tutorial sobre el entorno flexible de App Engine.

Objetivos

  • Desplegar la aplicación de muestra de Bookshelf en una única instancia de Compute Engine.
  • Escalar la aplicación horizontalmente a través de un grupo de instancias gestionado.
  • Distribuir el tráfico mediante el balanceo de carga de HTTP.
  • Responder a los cambios de tráfico a través del autoescalado.

Costes

En este tutorial, se usan componentes facturables de Cloud Platform, entre los que se incluyen los siguientes:

  • 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 previsto, usa la calculadora de precios. Es posible que los nuevos usuarios de Cloud Platform tengan derecho a una versión de prueba gratuita.

Antes de empezar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En GCP Console, en la página de selección de proyecto, selecciona o crea un proyecto de GCP.

    Ir a la página de selección de proyecto

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. Habilita lasCloud Datastore, Cloud Storage, and Cloud Pub/SubAPIAPI.

    Habilita lasAPI

  5. Instala e inicializa el SDK de Cloud.
  6. Instala PHP y Composer.

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 almacenan tus datos en Cloud Storage.

Ponle al segmento el mismo nombre que al ID de tu proyecto.

Para crear un segmento, sigue estas instrucciones:

  1. Invoca el siguiente comando:

    gsutil mb gs://[YOUR-PROJECT-ID]

    Sustituye [YOUR-PROJECT-ID] por el ID del proyecto.

  2. Establece la LCA predeterminada del segmento como public-read; con ello, los usuarios podrán ver las imágenes que suban:

    gsutil defacl set public-read gs://[YOUR-PROJECT-ID]

    Sustituye [YOUR-PROJECT-ID] por el ID del proyecto.

Clonar la aplicación de muestra

Podrás encontrar la aplicación de muestra 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 la muestra:

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

Configurar la aplicación

  1. Copia el archivo settings.yml.dist:

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

  3. Sustituye YOUR_PROJECT_ID por el ID del proyecto.

  4. Define el valor de bookshelf_backend como datastore.

  5. Guarda y cierra settings.yml.

Ejecutar la aplicación en el ordenador local

  1. Instala las dependencias:

    composer install
    
  2. Inicia un servidor web local:

    php -S localhost:8000 -t web
    
  3. Introduce la siguiente dirección en el navegador web:

    http://localhost:8000

Para 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 tu 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 ahí el código de la aplicación. Así, 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 para actualizar la aplicación no se necesita configurar nuevas imágenes o instancias; lo único que tienes que hacer es reiniciar una instancia o crear una nueva.

Primero, crea un repositorio en Cloud Console.

A continuación, envía el código de la aplicación al repositorio del proyecto:

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

donde [YOUR_PROJECT_ID] es el ID del proyecto y [YOUR_REPO] es el nombre que le has dado al repositorio que acabas de crear.

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 lo descargue y ejecute. Las instancias pueden tener una secuencia de comandos de inicio que se ejecute al iniciarlas o reiniciarlas.

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 del sistema que se requieren para esta aplicación, incluido PHP, la extensión PHP de MongoDB, Composer y NGINX. Luego, clona el código fuente de la aplicación desde el repositorio en la nube e 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 de YAML de la aplicación, incluidos los secretos del proyecto, se obtiene del servidor de metadatos informáticos. Este archivo se envía al servidor de metadatos cuando se crea la instancia de Compute.

# 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 de esta aplicación se instala mediante gce/nginx/bookshelf.conf. Después, 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 Google Cloud Logging. De este modo, se garantiza que el almacenamiento de registros añadido anteriormente en este tutorial funcionará según lo previsto.

Crear y configurar una instancia de Compute Engine

  1. Crea una instancia de Compute Engine:

    Linux/macOS 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 dirigido a la instancia:

    Linux/macOS 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, 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 la consola de Google Cloud Platform para supervisar y administrar la instancia. En la sección Recursos informáticos > Compute Engine, puedes ver la instancia en ejecución y conectarte a ella mediante SSH. En la sección Supervisión > Registros, puedes ver todos los registros generados por tus recursos de Compute Engine. Google Cloud Logging se configura de forma automática para recopilar registros de varios servicios comunes, incluido syslog.

Escalado horizontal con varias instancias

Despliegue de varias instancias con instancias administradas

Compute Engine puede escalarse en sentido horizontal fácilmente. Si se utiliza un grupo de instancias gestionado y la herramienta de adaptación dinámica de Compute Engine, Compute Engine podrá crear automáticamente nuevas instancias de la aplicación cuando sea necesario y desactivarlas cuando la demanda sea baja. Puedes configurar un balanceador de carga HTTP para distribuir el tráfico a las instancias de un grupo de instancias gestionado.

Crear un grupo de instancias gestionado

Un grupo de instancias gestionado es un grupo de instancias homogéneas basado en la misma plantilla de instancia. Este tipo de plantilla define la configuración de la instancia, incluidos el tamaño del disco, la imagen de origen, los permisos y los metadatos, entre los que se encuentran 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/startup-script.sh,project-config=config/settings.yml \
        --image ubuntu-15-04 \
        --tags http-server
    

  2. Luego, 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 el número de instancias del grupo. Cuando todas las instancias hayan terminado de ejecutar sus secuencias de comandos de inicio, se podrá acceder a ellas de forma individual mediante sus direcciones IP externas y el puerto 8080. Para encontrar las direcciones IP externas de las instancias, introduce gcloud compute instances list. Los nombres de las instancias administradas comienzan con el mismo prefijo, my-app, que se especificó en el parámetro --base-instance-name.

Crear un balanceador de carga

Con una instancia individual se pueden realizar pruebas o depuraciones, pero para distribuir el tráfico web es mejor usar un balanceador de carga que dirija el tráfico a las instancias disponibles de manera automática. 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 del estado para determinar qué instancias pueden distribuir tráfico:

    gcloud compute http-health-checks create ah-health-check \
        --request-path /_ah/health
    

  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, 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 balanceo de carga. Define a qué grupo de instancias debe dirigirse el tráfico y qué comprobación del estado se tiene que utilizar.

    gcloud compute backend-services create my-app-service \
        --http-health-check ah-health-check
    

  4. Añade el servicio de backend:

    gcloud compute backend-services add-backend my-app-service \
        --group my-app-group \
        --zone us-central1-f
    

  5. Crea una asignación de URLs y un proxy:

    La asignación de URLs define qué URL debe dirigirse a cada servicio de backend. En esta muestra, un servicio de backend distribuye todo el tráfico. Si quieres realizar peticiones de balanceo de carga entre distintas regiones o grupos, puedes crear varios servicios de backend. Un proxy recibe el tráfico y lo reenvía a los servicios de backend a través de las asignaciones de URLs.

    1. Crea la asignación de URLs:

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

    gcloud compute forwarding-rules create my-app-service-http-rule \
        --global \
        --target-http-proxy my-app-service-proxy \
        --port-range 80
    

Configurar la herramienta de adaptación dinámica

El balanceador de carga garantiza que el tráfico se distribuya entre todas las instancias que estén en buen estado. Pero ¿qué sucede si las instancias no pueden controlar todo el tráfico? Puedes añadir más instancias manualmente. Sin embargo, lo mejor sería configurar una herramienta de adaptación dinámica de Compute Engine para crear y eliminar instancias automáticamente en función de las demandas de tráfico.

  1. Crea una herramienta de adaptación dinámica:

    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 una herramienta de adaptación dinámica en el grupo de instancias administrado que realiza un escalado automático de hasta 10 instancias. Cuando el balanceador de carga presenta un valor de uso superior al 50 %, se añaden instancias nuevas; asimismo, cuando su valor de uso es inferior al 50 %, estas se eliminan.

  2. Crea una regla de cortafuegos si aún no lo has hecho:

    Linux/macOS 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 con la comprobación hasta que al menos una de las instancias indique un estado HEALTHY.

Visualizar la aplicación

  1. Obtén la dirección IP de reenvío del 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. Introduce la dirección IP de la lista en un navegador. Ahora, tu aplicación (ya autoescalada y con balanceo de carga) se está ejecutando en Google Compute Engine.

Administrar y supervisar el despliegue

Administrar varias instancias es tan fácil como hacerlo con una sola. Puedes usar la consola de GCP para supervisar el balanceo de carga, el autoescalado y el grupo de instancias gestionado.

Puedes administrar el grupo de instancias y la configuración de autoescalado mediante las secciones Recursos informáticos > Compute Engine > Grupos de instancias.

Por su parte, la configuración del balanceo de carga, incluidas las asignaciones de URLs y los servicios de backend, se puede gestionar mediante las secciones Recursos informáticos > 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 Escalado horizontal con varias instancias.

Eliminar 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, haz lo mismo con teardown.sh para retirar todos los recursos creados por la secuencia de comandos deploy.sh. De esta manera, el proyecto vuelve al estado en el que se encontraba antes de que se ejecutara la secuencia de comandos deploy.sh y se evita una facturación futura. Si quieres retirar la instancia única y el segmento de almacenamiento creados al principio del tutorial, realiza los pasos indicados en la siguiente 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 también manualmente.

Eliminar una instancia de Compute Engine

Puedes eliminar una instancia de Compute Engine de la siguiente forma:

  1. En GCP Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. Haz clic en la casilla de verificación para la instancia que deseas borrar.
  3. Haga clic en Borrar para borrar la instancia.

Eliminar un segmento de Cloud Storage

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

  1. En GCP Console, ve a la página Navegador de Cloud Storage.

    Ir a la página Navegador de Cloud Storage

  2. Haz clic en la casilla de verificación del depósito que deseas borrar.
  3. Haz clic en Borrar para borrar el depósito.

Siguientes pasos

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