Se usó la API de Cloud Translation para traducir esta página.

Implementa una app con GKE Autopilot y Cloud Spanner

Autopilot

En este instructivo, se describe cómo implementar una aplicación web en contenedores en un clúster de Google Kubernetes Engine (GKE) Autopilot y usar una base de datos de Google Spanner en el backend para almacenar datos. La aplicación de muestra administra una tabla de jugadores. Puedes agregar y borrar jugadores a través de la interfaz gráfica de usuario (GUI) de la app.

Spanner es un servicio de bases de datos relacional, distribuido de forma global y escalable de forma vertical completamente administrado que proporciona transacciones ACID y semántica de SQL sin comprometer el rendimiento y la alta disponibilidad.

Antes de leer este documento, asegúrate de estar familiarizado con Kubernetes.

Por qué GKE y Spanner

Como desarrollador, es posible que no desees dedicar tiempo a descubrir la cantidad de recursos de almacenamiento y procesamiento que necesita tu aplicación, o a predecir el consumo de RAM y CPU durante los períodos de fluctuación de las demandas o a preocuparte por las fallas de la aplicación en pico de carga.

Si usas GKE Autopilot como un servicio de Kubernetes completamente administrado y Spanner como un servicio de base de datos completamente administrado, puedes desarrollar e implementar apps más rápido en una infraestructura estable que simplifique la configuración y la administración de recursos. Autopilot de GKE controla la configuración y el escalamiento de la infraestructura para alojar tu app mediante la adición o eliminación de nodos hacia o desde el clúster, según los requisitos en el entorno de ejecución. De manera similar, Spanner puede escalar horizontalmente y de forma dinámica con una intervención manual mínima, a medida que cambian los requisitos de procesamiento o almacenamiento.

Por ejemplo, imagina que estás lanzando un juego que será el próximo éxito de ventas y esperas que se vuelva viral y atraiga mucho tráfico web durante su semana de lanzamiento. Spanner puede ayudarte a adaptarse a esta capacidad de procesamiento creciente. Para ello, proporciona la capacidad de aumentar, disminuir o reasignar los recursos de procesamiento de forma instantánea y, al mismo tiempo, mantener la disponibilidad máxima de la aplicación con GKE Autopilot.

Objetivos

En este instructivo, aprenderás a realizar lo siguiente:

Crear una base de datos de Spanner que almacene un registro de jugadores
Implementar una aplicación web de muestra llamada hello-app-cloud-spanner, con una interfaz gráfica de usuario.

En la siguiente tabla, se describen los recursos de Google Cloud que creas o usas, las variables con las que se identifican y los valores que se prescriben para el propósito de este instructivo:

Recurso	Variable	Valor
ID del proyecto de Google Cloud	`PROJECT_ID`	El ID del proyecto que se generó cuando creaste un proyecto. Ejemplo: `my-gcp-project`
Región de Compute	`COMPUTE_REGION`	La región de Compute Engine en la que deseas crear la instancia de Spanner y el clúster de GKE. Te recomendamos que elijas la región más cercana a la ubicación geográfica de tus clientes, pero para este instructivo, usa `us-west1`.
Instancia de Spanner	-	`hello-instance`
Base de datos de Spanner	-	`hello-database`
Clúster de GKE Autopilot	`CLUSTER_NAME`	`hello-cluster`
Espacio de nombres de Kubernetes	`NAMESPACE`	`hello-namespace`
Cuenta de servicio de Kubernetes	`KSA_NAME`	`ksa-helloapp`
Cuenta de servicio de IAM	`GSA_NAME`	`gsa-helloapp`
ID del proyecto de la cuenta de servicio de IAM	`GSA_PROJECT`	Tu `PROJECT_ID` de Google Cloud

Para los fines de este instructivo, te recomendamos que crees recursos nuevos, lo que facilita su borrado sin riesgos después de que hayas implementado la app de ejemplo. Sin embargo, si tienes espacios de nombres, cuentas de servicio de IAM y cuentas de servicio de Kubernetes existentes, puedes usarlos.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Asegúrate de completar los siguientes requisitos previos:

Selecciona o crea un proyecto

Puedes usar un proyecto existente o crear uno nuevo para este instructivo.

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las APIs

Enable the Artifact Registry, Compute Engine, GKE, and IAM Service Account Credentials APIs.

Enable the APIs

Configura Cloud Shell

En este instructivo, usarás Cloud Shell para ejecutar los comandos de gcloud y kubectl. Cloud Shell es un entorno de shell que se usa para administrar recursos alojados en Google Cloud. Viene preinstalado con la Google Cloud CLI y la herramienta de línea de comandos de kubectl.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Se abrirá una sesión de Cloud Shell dentro de un marco en la parte inferior en la consola.

Antes de ejecutar comandos en este instructivo, asegúrate de que tu proyecto predeterminado esté configurado como el ID del proyecto en el que deseas implementar la app de ejemplo. Si aún no está configurado, ejecuta el siguiente comando en Cloud Shell:

gcloud config set project PROJECT_ID

Reemplaza PROJECT_ID por el ID del proyecto.

Asigna roles de IAM

Asegúrate de que tu cuenta de Google Cloud tenga los roles de IAM necesarios para este instructivo.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/iam.serviceAccountAdmin, roles/serviceusage.serviceUsageConsumer, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/spanner.admin, roles/container.admin

$ gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE

Replace PROJECT_ID with your project ID.
Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
Replace ROLE with each individual role.

Configura Spanner

Para configurar Spanner, debes crear una instancia de Spanner y una base de datos de Spanner.

Crear una instancia de Spanner

Una instancia de Spanner es una asignación de recursos que usan las bases de datos de Spanner creadas en esa instancia.

Crea una instancia de Spanner llamada hello-instance con una configuración regional y la capacidad de procesamiento de 100 unidades de procesamiento.

gcloud spanner instances create hello-instance \
    --config=regional-COMPUTE_REGION \
    --description="Spanner sample instance" \
    --processing-units=100

Reemplaza COMPUTE_REGION por us-west1 para este instructivo.

Crear una base de datos de Spanner

Una base de datos de Spanner incluye tus tablas, vistas y índices. Una base de datos hereda propiedades de su instancia superior, como su configuración (regional o multirregional), la capacidad de procesamiento disponible y el almacenamiento.

Crear una base de datos de Spanner llamada hello-database con una tabla llamada Players, mediante el dialecto GoogleSQL Ejecuta la siguiente consulta en Cloud Shell:

gcloud spanner databases create hello-database \
    --instance=hello-instance \
    --database-dialect=GOOGLE_STANDARD_SQL \
    --ddl="CREATE TABLE Players (
        PlayerUuid STRING(36) NOT NULL,
        FirstName STRING(1024),
        LastName STRING(1024),
        BirthDate DATE) PRIMARY KEY(PlayerUuid)"

Crea un clúster de GKE Autopilot

Después de configurar Spanner, crea un clúster de Autopilot y usa la federación de identidades para cargas de trabajo para GKE para acceder a tu base de datos de manera segura y administrable.

Crea un clúster de Autopilot con el nombre hello-cluster: Los clústeres de Autopilot tienen la federación de identidades para cargas de trabajo para GKE habilitada de forma predeterminada.

gcloud container clusters create-auto CLUSTER_NAME \
  --region=COMPUTE_REGION

Reemplaza lo siguiente:

CLUSTER_NAME: hello-cluster
COMPUTE_REGION: La región de Compute Engine del clúster. Para este instructivo, usa la misma región, us-west1, en la que creaste la instancia de Spanner. Te recomendamos crear la instancia de Spanner y el clúster de GKE Autopilot dentro de la misma región para reducir la latencia.

La creación del clúster puede demorar entre 8 y 10 minutos.

El resultado es similar al siguiente:

NAME: hello-cluster
LOCATION: us-west1
MASTER_VERSION: 1.26.5-gke.1200
MASTER_IP: 192.0.2.1
MACHINE_TYPE: e2-medium
NODE_VERSION: 1.26.5-gke.1200
NUM_NODES: 3
STATUS: RUNNING

Configura el clúster a fin de usar la federación de identidades para cargas de trabajo para GKE

Configura tu clúster a fin de autenticarte en Google Cloud mediante la federación de identidades para cargas de trabajo para GKE antes de implementar la app.

Obtén credenciales para acceder al clúster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
  --region=COMPUTE_REGION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: hello-cluster
- COMPUTE_REGION: us-west1
Esto actualiza un archivo kubeconfig con las credenciales y la información del extremo adecuadas para que kubectl apunte a tu clúster.
Crea un espacio de nombres para usar en la cuenta de servicio de Kubernetes. También puedes usar el espacio de nombres predeterminado o cualquier espacio de nombres existente.
```
kubectl create namespace NAMESPACE
```
Reemplaza NAMESPACE por hello-namespace, el nombre del espacio de nombres nuevo que estás creando.
Crea una cuenta de servicio de Kubernetes para que tu aplicación use:
```
kubectl create serviceaccount KSA_NAME \
  --namespace NAMESPACE
```
Reemplaza lo siguiente:
- KSA_NAME: ksa-helloapp, el nombre de la cuenta de servicio de Kubernetes nueva que estás creando.
- NAMESPACE: hello-namespace
Crea una cuenta de servicio de IAM para tu aplicación:
```
gcloud iam service-accounts create GSA_NAME \
  --project=GSA_PROJECT
```
Reemplaza lo siguiente:
- GSA_NAME: gsa-helloapp, el nombre de la cuenta de servicio de IAM nueva que estás creando.
- GSA_PROJECT: es el ID del proyecto de Google Cloud. En este instructivo, crearás la cuenta de servicio de IAM en el mismo proyecto de Google Cloud en el que implementas la app de muestra. Por lo tanto, tu GSA_PROJECT y PROJECT_ID de Google Cloud son los mismos.

Agrega una vinculación de política de IAM para que tu cuenta de servicio de IAM lea y escriba en Spanner:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Reemplaza lo siguiente:

PROJECT_ID: El ID del proyecto de Google Cloud.
GSA_NAME: gsa-helloapp

Ejemplo:

gcloud projects add-iam-policy-binding my-gcp-project \
  --member "serviceAccount:gsa-helloapp@my-gcp-project.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Para permitir que la cuenta de servicio de Kubernetes actúe en nombre de la cuenta de servicio de IAM, agrega una vinculación de política de IAM entre las dos. Esta vinculación permite que la cuenta de servicio de Kubernetes actúe como la cuenta de servicio de IAM para que la cuenta de servicio de Kubernetes pueda leer y escribir en Spanner.
```
gcloud iam service-accounts add-iam-policy-binding GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
```
Reemplaza lo siguiente:
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: El ID del proyecto de Google Cloud.
- PROJECT_ID: El ID del proyecto de Google Cloud.
- NAMESPACE: hello-namespace
- KSA_NAME: ksa-helloapp
Ejemplo:
```
gcloud iam service-accounts add-iam-policy-binding gsa-helloapp@my-gcp-project.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:my-gcp-project.svc.id.goog[hello-namespace/ksa-helloapp]"
```
Anota la cuenta de servicio de Kubernetes con la dirección de correo electrónico de la cuenta de servicio de IAM. Esto permite que tu app de ejemplo sepa qué cuenta de servicio usar para acceder a los servicios de Google Cloud. Por lo tanto, cuando la app usa cualquier biblioteca cliente estándar de la API de Google para acceder a los servicios de Google Cloud, usa esa cuenta de servicio de IAM.
```
kubectl annotate serviceaccount KSA_NAME \
  --namespace NAMESPACE \
  iam.gke.io/gcp-service-account=GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com
```
Reemplaza lo siguiente:
- KSA_NAME: ksa-helloapp
- NAMESPACE: hello-namespace
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: El ID del proyecto de Google Cloud.
Ejemplo:
```
kubectl annotate serviceaccount ksa-helloapp \
  --namespace hello-namespace \
  iam.gke.io/gcp-service-account=gsa-helloapp@my-gcp-project.iam.gserviceaccount.com
```
Nota: Si la vinculación de IAM no existe, esta anotación por sí sola no otorga acceso al Pod para que imite la cuenta de servicio de IAM.

Implementa la app de muestra en el clúster

Ahora que configuraste GKE y Spanner con los servicios y la autenticación necesarios, estás listo para implementar la app de muestra hello-app-cloud-spanner.

Clona la app de muestra del repositorio de GitHub a tu Cloud Shell:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Haz clic en Abrir editor en la barra de herramientas de la ventana de la terminal para iniciar el editor de Cloud Shell.

Para obtener más información, consulta Descripción general de la interfaz de Editor de Cloud Shell.
Abre el panel Explorador del editor de Cloud Shell y navega al directorio kubernetes-engine-samples/databases/hello-app-cloud-spanner/k8s.
Abre el archivo deployment.yaml y actualiza el campo serviceAccountName reemplazando <KSA_NAME> por ksa-helloapp, el nombre de tu cuenta de servicio de Kubernetes.

Figura 1. Actualiza el nombre de la cuenta de servicio de Kubernetes en el archivo de implementación.
Cierra el Editor de Cloud Shell y regresa a la terminal de Cloud Shell.
En la terminal de Cloud Shell, navega al directorio hello-app-cloud-spanner:
```
cd kubernetes-engine-samples/databases/hello-app-cloud-spanner
```
Implementa la aplicación:
```
kubectl apply -f k8s/deployment.yaml -n=NAMESPACE
```
Reemplaza NAMESPACE por hello-namespace.

Espera a que se implemente la aplicación con STATUS como Running:

kubectl get pods -n=NAMESPACE --watch

Reemplaza NAMESPACE por hello-namespace.

El resultado es similar al siguiente:

NAME                                       READY   STATUS              RESTARTS   AGE
hello-app-cloud-spanner-765c9b8779-lfcrc   0/1     ContainerCreating   0          87s
hello-app-cloud-spanner-765c9b8779-lfcrc   1/1     Running             0          3m15s

Presiona Ctrl+C en el teclado para regresar al símbolo del sistema y ejecutar más comandos.

Expón la app de muestra a Internet

Para exponer un servicio de Kubernetes fuera del clúster, debes crear un servicio de tipo LoadBalancer. Este tipo de servicio genera una dirección IP de balanceador de cargas externo para tus Pods, a la que se puede acceder a través de Internet.

Implementa el balanceador de cargas:
```
kubectl apply -f k8s/service.yaml -n=NAMESPACE
```
Reemplaza NAMESPACE por hello-namespace.
Busca una dirección IP externa que se asigne:
```
kubectl get service -n=NAMESPACE --watch
```
Reemplaza NAMESPACE por hello-namespace.
Una vez asignado, copia el EXTERNAL-IP (por ejemplo, 203.0.113.0) y ábrelo en un navegador. Se abrirá una interfaz web que muestra y administra la base de datos de los jugadores.

Puedes usar la GUI de la app para crear o borrar registros de jugadores, que se guardan en la base de datos de Spanner.

Agrega o borra jugadores. — **Figura 2.** Crea o borra jugadores en el registro.

Ejecuta la siguiente consulta para verificar si la base de datos de Spanner se actualizó con tus entradas:

gcloud spanner databases execute-sql hello-database \
  --instance=hello-instance \
  --sql="SELECT * FROM Players LIMIT 10"

El resultado es similar al siguiente:

PlayerUuid: a1f34bbf-929c-498d-8b16-39bbb29d70e3
FirstName: John
LastName: Smith
BirthDate: 1997-07-12

PlayerUuid: d634e157-96ea-45f2-be3f-fb907ced188e
FirstName: Jane
LastName: Doe
BirthDate: 2013-07-12

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra tu proyecto

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

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

Borra un proyecto de Google Cloud:

gcloud projects delete PROJECT_ID

Si borraste el proyecto, tu limpieza se completó. Si no borraste el proyecto, borra los recursos de GKE y Spanner.

Borra recursos de GE

Borra el servicio. De este modo, se desasigna el balanceador de cargas de Cloud creado para él:
```
kubectl delete service hello-app-cloud-spanner -n=NAMESPACE
```
Reemplaza NAMESPACE por hello-namespace.
Borra el clúster de GKE. De este modo, se borran los recursos que constituyen un clúster, como las instancias de procesamiento, los discos y los recursos de red:
```
gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION
```
Reemplaza lo siguiente:
- CLUSTER_NAME: hello-cluster
- COMPUTE_REGION: us-west1

Borra recursos de Spanner

Borra la base de datos de Spanner:

gcloud spanner databases delete hello-database --instance=hello-instance

Borra la instancia de Spanner:

Precaución: Si borras una instancia, se quitará de forma permanente junto con todas sus bases de datos.
```
gcloud spanner instances delete hello-instance
```

¿Qué sigue?

Obtén información sobre cómo crear un clúster de GKE para tu instalación de Agones.
Conoce las prácticas recomendadas para usar Spanner como base de datos de videojuegos.
Obtén más información sobre cómo implementar una base de datos de PostgreSQL con alta disponibilidad en GKE.
Conoce las prácticas recomendadas para implementar bases de datos en GKE.