Cómo ejecutar Bookshelf para PHP en Kubernetes Engine

En este instructivo, se muestra cómo ejecutar la app de Bookshelf para PHP en Google Kubernetes Engine (GKE). Síguelo para crear contenedores y, luego, implementar una aplicación web de PHP existente en GKE. Es recomendable que revises la documentación de la app de Bookshelf como parte del instructivo para el entorno estándar de App Engine.

Para este instructivo, se presupone que tienes conocimientos de PHP y que ya has instalado PHP 5.6, 7.0 o 7.1. Además, debes descargar Composer. Para este instructivo, se presupone que el archivo ejecutable de Composer se instaló de manera global.

Objetivos

  • Crear un clúster de GKE.
  • Organizar una app de PHP en contenedores.
  • Crear un frontend replicado para la app de Bookshelf.
  • Crear un backend replicado para la app de Bookshelf.
  • Crear un servicio con balanceo de cargas para enrutar el tráfico HTTP al frontend de Bookshelf.

Costos

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

  • GKE
  • Compute Engine
  • Cloud Storage
  • Cloud Datastore
  • Cloud Pub/Sub

Usa la calculadora de precios para generar una estimación de 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 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, Kubernetes Engine, Cloud Storage, Cloud Pub/Sub y Google+ API necesarias.

    Habilita las API

  5. Install and initialize the Cloud SDK.
  6. Instala Docker. Se usa para compilar imágenes de contenedores de manera local.
  7. Instala kubectl.
    gcloud components install kubectl

Cómo crear un clúster de GKE

Un clúster de GKE es un conjunto administrado de máquinas virtuales de Compute Engine que operan como un clúster de GKE único. Para este instructivo, se necesita un clúster con dos nodos como mínimo, que deben tener acceso a todas las API de Google.

  1. Crea el clúster. Reemplaza [YOUR_GCP_ZONE] por la zona de GCP en la que quieras alojar el clúster.

    gcloud container clusters create bookshelf \
        --scopes "cloud-platform" \
        --num-nodes 2 \
        --enable-basic-auth \
        --issue-client-certificate \
        --enable-ip-alias \
        --zone [YOUR_GCP_ZONE]
    
  2. Verifica que tengas acceso al clúster. El siguiente comando muestra una lista de los nodos presentes en el clúster de tu contenedor y señala que el clúster está activo y funcionando, y que puedes acceder a él.

    kubectl get nodes
    

Para crear recursos en un clúster de GKE, se usa el comando kubectl. Para obtener más información sobre kubectl, consulta las operaciones de clúster de GKE. En general, se usa gcloud para administrar recursos en el proyecto de GCP y kubectl para administrar recursos en el clúster de GKE. Un proyecto puede tener varios clústeres, lo que simplifica el trabajo con clústeres conformados por distintos tipos de máquinas para satisfacer necesidades variadas.

Cuando creas un clúster con gcloud, automáticamente se configura la autenticación para kubectl. En los clústeres creados con Google Cloud Platform Console se puede configurar la autenticación a través del comando gcloud container clusters get-credentials.

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. Navega al directorio de muestra.

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

Inicialización de 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. En GCP Console, abre Cloud Datastore.

    Ir a Cloud Datastore

  2. Selecciona una región para tu almacén de datos y haz clic en Continuar hasta que llegues a la página Crear una entidad. Cierra la ventana, ya que la app de Bookshelf está lista para crear entidades en Cloud Datastore.

Cómo crear un depósito de Cloud Storage

La app de Bookshelf utiliza Cloud Storage para almacenar archivos de imagen.

Las instrucciones siguientes muestran cómo crear un depósito de Cloud Storage. Los depósitos son los contenedores básicos para alojar tus datos en Cloud Storage.

  1. En una ventana de la terminal, ingresa el siguiente comando:

    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 app de Bookshelf, asigna a la lista de control de acceso (LCA) predeterminada del depósito el valor public-read.

    gsutil defacl set public-read gs://[YOUR-BUCKET-NAME]

    Cómo configurar la app

    1. Ve al directorio getting-started-php/optional-kubernetes-engine y 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. Asigna a bookshelf_backend el valor datastore.

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

    Cloud Datastore es un servicio completamente administrado que se inicializa y se conecta a la app de App Engine automáticamente. No es necesario que lo configures.

    Cómo organizar la app en contenedores

    La app de muestra incluye un Dockerfile que se usa para crear su imagen de Docker. Esta imagen de Docker ejecuta la app en GKE.

    # The Google App Engine php runtime is Debian Jessie with PHP installed
    # and various os-level packages to allow installation of popular PHP
    # libraries. The source is on github at:
    #   https://github.com/GoogleCloudPlatform/php-docker
    FROM gcr.io/google_appengine/php
    
    # Add our NGINX and php.ini config
    ENV DOCUMENT_ROOT=${APP_DIR}/web
    
    # Workaround for AUFS-related permission issue:
    # See https://github.com/docker/docker/issues/783#issuecomment-56013588
    RUN cp -R ${APP_DIR} ${APP_DIR}-copy; rm -r ${APP_DIR}; mv ${APP_DIR}-copy ${APP_DIR}; chmod -R 550 ${APP_DIR}; chown -R root.www-data ${APP_DIR}
    
    La app de muestra también incluye un archivo .dockerignore con una lista de rutas de acceso a archivos que no se incluyen en el contenedor de Docker resultante. Por lo general, este archivo incluye artefactos de compilación así como instalaciones de dependencias locales.

    test/*
    coverage/*
    
  3. Compila la imagen de Docker de la app.

    docker build -t gcr.io/[YOUR_PROJECT_ID]/bookshelf
    
  4. Envía la imagen a Google Container Registry para que el clúster pueda acceder a ella.

    gcloud docker -- push gcr.io/[YOUR_PROJECT_ID]/bookshelf
    

Cómo organizar el trabajador en contenedores

La app de muestra incluye un Dockerfile que se usa para crear la imagen de Docker del trabajador. Esta imagen de Docker se usa para ejecutar el trabajador en GKE.

# The Google App Engine php runtime is Debian Jessie with PHP installed
# and various os-level packages to allow installation of popular PHP
# libraries. The source is on github at:
#   https://github.com/GoogleCloudPlatform/php-docker
FROM gcr.io/google_appengine/php

# override the default CMD for the pubsub worker
CMD php bin/pubsub/entrypoint.php
  1. Compila la imagen de Docker de la app.

    docker build -t gcr.io/[YOUR_PROJECT_ID]/bookshelf-worker \
        --file Dockerfile.worker .
    
  2. Envía la imagen a Google Container Registry para que el clúster pueda acceder a ella.

    gcloud docker -- push gcr.io/[YOUR_PROJECT_ID]/bookshelf-worker
    

Cómo implementar el frontend de Bookshelf

La app de Bookshelf tiene un servidor de frontend que se ocupa de las solicitudes web y un trabajador de backend que procesa los libros y agrega información adicional.

Los recursos del clúster que se necesitan para ejecutar el frontend se definen en bookshelf-frontend.yaml. Estos recursos se describen como una implementación de Kubernetes. Las implementaciones facilitan la creación y la actualización de un conjunto de réplicas y los pods asociados.

# This file configures the bookshelf application frontend. The frontend serves
# public web traffic.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: bookshelf-frontend
  labels:
    app: bookshelf
# The bookshelf frontend replica set ensures that at least 3
# instances of the bookshelf app are running on the cluster.
# For more info about Pods see:
#   https://cloud.google.com/container-engine/docs/pods/
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: bookshelf
        tier: frontend
    spec:
      containers:
      - name: bookshelf-app
        # Replace $GCLOUD_PROJECT with your project ID or use `make template`.
        image: gcr.io/$GCLOUD_PROJECT/bookshelf
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        # The bookshelf process listens on port 8080 for web traffic by default.
        ports:
        - name: http-server
          containerPort: 8080
  1. En bookshelf-frontend.yaml, reemplaza [YOUR_PROJECT_ID] por el ID de tu proyecto.

  2. Implementa los recursos en el clúster.

    kubectl create -f bookshelf-frontend.yaml
    
  3. Haz un seguimiento del estado de la implementación.

    kubectl get deployments
    

    La implementación estará completa cuando tenga la misma cantidad de pods disponibles y pods deseados. Si tienes problemas con la implementación, bórrala y empieza de nuevo.

    kubectl delete deployments bookshelf-frontend
    
  4. Cuando finalice la implementación, podrás ver los pods que esta creó.

    kubectl get pods
    

Cómo implementar el backend de Bookshelf

El backend de Bookshelf se implementa del mismo modo que el frontend.

# Copyright 2015 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License

# This file configures the bookshelf task worker. The worker is responsible
# for processing book requests and updating book information.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: bookshelf-worker
  labels:
    app: bookshelf
# The bookshelf worker replica set ensures that at least 2 instances of the
# bookshelf worker pod are running on the cluster.
# For more info about Pods see:
#   https://cloud.google.com/container-engine/docs/pods/
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: bookshelf
        tier: worker
    spec:
      containers:
      - name: bookshelf-app
        # Replace $GCLOUD_PROJECT with your project ID or use `make template`.
        image: gcr.io/$GCLOUD_PROJECT/bookshelf-worker
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        # The bookshelf process listens on port 8080 for web traffic by default.
        ports:
        - name: ratchet-server
          containerPort: 8080
  1. En bookshelf-worker.yaml, reemplaza [YOUR_PROJECT_ID] por el ID de tu proyecto.

  2. Implementa los recursos en el clúster.

    kubectl create -f bookshelf-worker.yaml
    
  3. Verifica que los pods se estén ejecutando.

    kubectl get pods
    

Cómo crear el servicio de Bookshelf

Los servicios de Kubernetes proporcionan un punto de acceso único a un conjunto de pods. Si bien es posible acceder a un solo pod, los pods son efímeros, por lo que te recomendamos dirigirte a un conjunto de pods con un solo extremo. En la app de Bookshelf, el servicio de Bookshelf te permite acceder a los pods del frontend desde una dirección IP única. Este servicio se define en bookshelf-service.yaml.

# The bookshelf service provides a load-balancing proxy over the bookshelf
# frontend pods. By specifying the type as a 'LoadBalancer', Container Engine
# will create an external HTTP load balancer.
# For more information about Services see:
#   https://cloud.google.com/container-engine/docs/services/
# For more information about external HTTP load balancing see:
#   https://cloud.google.com/container-engine/docs/load-balancer
apiVersion: v1
kind: Service
metadata:
  name: bookshelf-frontend
  labels:
    app: bookshelf
    tier: frontend
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: http-server
  selector:
    app: bookshelf
    tier: frontend

Ten en cuenta que los pods y el servicio que usa los pods son independientes. Kubernetes usa etiquetas para seleccionar los pods a los que se dirige un servicio. Con las etiquetas, puedes contar con un servicio que se dirija a los pods desde conjuntos de réplicas diferentes y tener varios servicios que apunten a un pod en particular.

  1. Crea el servicio de Bookshelf.

    kubectl create -f bookshelf-service.yaml
    
  2. Obtén la dirección IP externa del servicio.

    kubectl describe service bookshelf
    

    Ten en cuenta que puede llevar hasta 60 segundos asignar la dirección IP. La dirección IP externa aparece en LoadBalancer Ingress.

Cómo acceder a la app de Bookshelf

Ya implementaste todos los recursos necesarios para ejecutar la app de Bookshelf en GKE. Usa la dirección IP externa del paso anterior para cargarla en tu navegador web y crear libros. Si implementaste el trabajador, los libros se actualizan automáticamente con la información de la API de Google Libros.

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:

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, haz lo siguiente:

  1. In the GCP Console, go to the Projects page.

    Go to the Projects page

  2. In the project list, select the project you want to delete and click Delete .
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Borra el clúster

Cuando se borra el clúster, se quitan todos los recursos de GKE y Compute Engine. Sin embargo, los recursos de Cloud Storage, Cloud Datastore y Cloud Pub/Sub que hayas usado deben quitarse de forma manual.

Usa el siguiente comando para borrar el clúster. Reemplaza [YOUR_GCP_ZONE] por la zona que usaste cuando creaste el clúster.

gcloud container clusters delete bookshelf --zone [YOUR_GCP_ZONE]

Próximos pasos

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