Rumpus arcoíris de microservicios

1. Introducción

Última actualización: 06/05/2021

Microservicio Rainbow Rumpus

¿Alguna vez participaste en una pelea de bolas de nieve en la que te mueves y tiras bolas de nieve a otras personas de manera divertida? De lo contrario, pruébala algún día. Pero ahora, en lugar de correr el riesgo de golpearse físicamente, puedes compilar un servicio pequeño y accesible a través de la red (un microservicio) que participará en una batalla épica contra otros microservicios, lanzando arcoíris en lugar de bolas de nieve.

Tal vez te preguntes… Pero ¿cómo un microservicio “lanza” un arcoíris a otros microservicios? Un microservicio puede recibir solicitudes de red (generalmente a través de HTTP) y devolver respuestas. Hay un “administrador de Arena” que le enviará al microservicio el estado actual del estadio y, luego, responderá con un comando que especifique qué hacer.

Por supuesto, el objetivo es ganar, pero aprenderás a compilar y a implementar microservicios en Google Cloud durante el proceso.

Cómo funciona

Compilarás un microservicio con la tecnología que desees (o elegirás los activadores de Go, Java, Kotlin, Scala, NodeJS o Python) y, luego, lo implementarás en Google Cloud. Cuando lo implementes, deberás informarnos la URL de tu microservicio y, luego, la agregaremos al campo de entrenamiento.

La arena contiene a todos los jugadores de una batalla determinada. Rainbow Rumpus tendrá sus propias arenas. Cada jugador representa un microservicio que se mueve y lanza arcoíris a los demás jugadores.

Alrededor de una vez por segundo, nuestro administrador de arena llamará a tu microservicio y enviará el estado actual de este (donde se encuentran los jugadores) y tu microservicio responderá con un comando sobre qué hacer. En la arena, puedes avanzar, girar a la izquierda o la derecha, o lanzar un arcoíris. Los arcoíris viajarán hasta tres espacios en la dirección hacia la que apunta el jugador. Si el arcoíris “golpea” otro, el lanzador obtiene un punto y el jugador que batea pierde un punto. El tamaño de la arena se ajusta automáticamente según la cantidad actual de jugadores.

Así se ve un estadio anterior:

20628e6bd442bd11.png

Ejemplo de arena de Battle One

Conflictos rotativos

En la arena, es posible que varios jugadores intenten realizar acciones contradictorias. Por ejemplo, dos jugadores pueden intentar moverse al mismo espacio. En caso de conflicto, prevalecerá el microservicio que tenga el tiempo de respuesta más rápido.

Mirar la batalla

Para ver cómo se desempeña tu microservicio en la batalla, consulta la arena en vivo.

API de Battle

Para trabajar con nuestro administrador de arenas, tu microservicio deberá implementar una API específica para participar en la arena. El administrador de la arena enviará el estado actual de la arena en una solicitud POST HTTP a la URL que nos proporciones, con la siguiente estructura JSON:

{
  "_links": {
    "self": {
      "href": "https://YOUR_SERVICE_URL"
    }
  },
  "arena": {
    "dims": [4,3], // width, height
    "state": {
      "https://A_PLAYERS_URL": {
        "x": 0, // zero-based x position, where 0 = left
        "y": 0, // zero-based y position, where 0 = top
        "direction": "N", // N = North, W = West, S = South, E = East
        "wasHit": false,
        "score": 0
      }
      ... // also you and the other players
    }
  }
}

Tu respuesta HTTP debe tener el código de estado 200 (OK) con un cuerpo de respuesta que contenga tu próximo movimiento, codificado como un solo carácter en mayúsculas de una de las siguientes opciones:

F <- move Forward
R <- turn Right
L <- turn Left
T <- Throw

¡Esto es todo lo que hay sobre este tema! Veamos un instructivo para implementar un microservicio en Cloud Run, un servicio de Google Cloud para ejecutar microservicios y otras aplicaciones.

2. Accede a Google Cloud

Para poder implementar tu microservicio en Cloud Run, deberás acceder a Google Cloud. Aplicaremos un crédito a tu cuenta y no deberás ingresar una tarjeta de crédito. Por lo general, es menos problemático usar una cuenta personal (p.ej., gmail.com) en lugar de una cuenta de G Suite porque, a veces, los administradores de G Suite impiden que sus usuarios usen ciertas funciones de Google Cloud. Además, la consola web que usaremos debería funcionar bien con Chrome o Firefox, pero es posible que tenga problemas en Safari.

3. Implementa tu microservicio

Puedes compilar tu microservicio con cualquier tecnología e implementarlo en cualquier lugar, siempre y cuando sea accesible de forma pública y cumpla con la API de Battle. Sin embargo, para facilitarte las cosas, te ayudaremos a comenzar con un servicio de muestra y, luego, a implementarlo en Cloud Run.

Elija su muestra para comenzar

Existen numerosos ejemplos de microservicios de batalla a partir de los cuales puedes comenzar:

Kotlin y Spring Boot

Origen

Kotlin y Micronauta

Origen

Kotlin y Quarkus

Origen

Java y Spring Boot

Origen

Java y Quarkus

Origen

Go

Origen

Node.js y Express

Origen

Python y Flask

Origen

Después de decidir con qué muestra comenzar, haz clic en “Implementar en Cloud Run” botón arriba. Esto iniciará Cloud Shell (una consola basada en la Web que se conecta a una máquina virtual en la nube) en la que se clonará la fuente y, luego, se compilará en un paquete implementable (una imagen de contenedor de Docker), que luego se subirá a Google Container Registry y se implementará en Cloud Run.

Cuando se te solicite, especifica la región us-central1.

En la siguiente captura de pantalla, se muestra el resultado de Cloud Shell para la compilación y la implementación de microservicios.

d88e40430706a32b.png

Verifica que el microservicio funcione

En Cloud Shell, puedes realizar una solicitud al microservicio recién implementado. Para ello, reemplaza YOUR_SERVICE_URL por la URL de tu servicio (que se encuentra en Cloud Shell después de la línea “Your application is now live here”):

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  https://YOUR_SERVICE_URL

Deberías ver la cadena de respuesta de F, L, R o T.

4. Solicita la inclusión en la arena

Para unirte a la función, deberás unirte a una arena. Abre rainbowrumpus.dev y haz clic en Unirse en un campo en el que proporcionarás la URL de tu microservicio.

5. Marca y Implementa cambios

Antes de poder realizar cambios, debes configurar cierta información en Cloud Shell sobre el proyecto de GCP y la muestra que usaste. Primero, enumera tus proyectos de GCP:

gcloud projects list

Es probable que solo tengas un proyecto. Copia el PROJECT_ID de la primera columna y pégalo en el siguiente comando (reemplaza YOUR_PROJECT_ID por tu ID de proyecto real) para establecer una variable de entorno que usaremos en comandos posteriores:

export PROJECT_ID=YOUR_PROJECT_ID

Ahora, establece otra variable de entorno para la muestra que usaste, de modo que en los comandos posteriores podamos especificar el directorio y el nombre del servicio correctos:

# Copy and paste ONLY ONE of these
export SAMPLE=kotlin-micronaut
export SAMPLE=kotlin-quarkus
export SAMPLE=kotlin-springboot
export SAMPLE=java-quarkus
export SAMPLE=java-springboot
export SAMPLE=go
export SAMPLE=nodejs
export SAMPLE=python

Ahora, puedes editar la fuente para tu microservicio desde Cloud Shell. Para abrir el editor basado en la Web de Cloud Shell, ejecuta este comando:

cloudshell edit cloudbowl-microservice-game/samples/$SAMPLE/README.md

Luego, verás más instrucciones para realizar cambios.

f910c9ef7b51c406.png

Cloud Shell con el editor y el proyecto de muestra abierto

Después de guardar los cambios, inicia la aplicación en Cloud Shell con el comando del archivo README.md, pero primero asegúrate de estar en el directorio de muestra correcto de Cloud Shell:

cd cloudbowl-microservice-game/samples/$SAMPLE

Una vez que se esté ejecutando la aplicación, abre una pestaña nueva de Cloud Shell y prueba el servicio con curl:

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  http://localhost:8080

Cuando todo esté listo para implementar los cambios, compila tu proyecto en Cloud Shell con el comando pack. Este comando usa Buildpacks para detectar el tipo de proyecto, compilarlo y crear el artefacto implementable (una imagen de contenedor de Docker).

# Make sure you are in a Cloud Shell tab where you set the PROJECT_ID
# and SAMPLE env vars. Otherwise, set them again.
pack build gcr.io/$PROJECT_ID/$SAMPLE \
  --path ~/cloudbowl-microservice-game/samples/$SAMPLE \
  --builder gcr.io/buildpacks/builder

Ahora que se creó la imagen de contenedor, usa el comando docker (en Cloud Shell) para enviarla a Google Container Registry, de modo que Cloud Run pueda acceder a ella:

docker push gcr.io/$PROJECT_ID/$SAMPLE

Ahora implementa la versión nueva en Cloud Run:

gcloud run deploy $SAMPLE \
          --project=$PROJECT_ID \
          --platform=managed \
          --region=us-central1 \
          --image=gcr.io/$PROJECT_ID/$SAMPLE \
          --allow-unauthenticated

Ahora el estadio usará tu nueva versión.

6. Desarrollo local (opcional)

Puedes trabajar en tu proyecto de manera local con tu propio IDE; para ello, sigue estos pasos:

  1. [En Cloud Shell] Comprime la muestra con el comando siguiente:
# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples
zip -r cloudbowl-sample.zip $SAMPLE
  1. [En Cloud Shell] Descarga el archivo ZIP en tu máquina:
cloudshell download-file cloudbowl-sample.zip
  1. [En tu máquina] Descomprime el archivo y, luego, realiza y prueba los cambios.
  2. [En tu máquina] Instala gcloud CLI
  3. [En tu máquina] Accede a Google Cloud:
gcloud auth login
  1. [En tu máquina] Configura las variables de entorno PROJECT_ID y SAMPLE con los mismos valores que en Cloud Shell.
  2. [En tu máquina] Usa Cloud Build para compilar el contenedor (desde el directorio raíz del proyecto):
gcloud alpha builds submit . \
  --pack=image=gcr.io/$PROJECT_ID/$SAMPLE \
  --project=$PROJECT_ID
  1. [En tu máquina] Implementa el contenedor nuevo:
gcloud run deploy $SAMPLE \
  --project=$PROJECT_ID \
  --platform=managed \
  --region=us-central1 \
  --image=gcr.io/$PROJECT_ID/$SAMPLE \
  --allow-unauthenticated

7. Entrega continua

Configura SCM

Configura GitHub para poder colaborar con tu equipo en tu microservicio:

  1. Acceder a GitHub
  2. Cómo crear un repositorio nuevo
  3. Si estás trabajando en tu máquina local, puedes usar la interfaz de línea de comandos (CLI) de Git o la aplicación de la GUI de escritorio de GitHub (Windows o Mac). Si usas Cloud Shell, deberás usar la CLI de git. Para obtener el código de tu microservicio en GitHub, sigue las instrucciones de la CLI o GitHub Desktop.

Envía tu código con la CLI de git

  1. Sigue las instrucciones de Git-over-HTTPS con un token de acceso personal.
  2. Selecciona “Repo”. alcance
  3. Configura Git:
git config --global credential.helper \
  'cache --timeout=172800'
git config --global push.default current
git config --global user.email "YOUR@EMAIL"
git config --global user.name "YOUR NAME"
  1. Configura variables de entorno para la organización y el repositorio de GitHub (https://github.com/ORG/REPO)
export GITHUB_ORG=YOUR_GITHUB_ORG
export GITHUB_REPO=YOUR_GITHUB_REPO
  1. Envía tu código al nuevo repositorio
# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples/$SAMPLE
git init
git add .
git commit -m init
git remote add origin https://github.com/$GITHUB_ORG/$GITHUB_REPO.git
git branch -M main

# This will now ask for your GitHub username & password
# for the password use the personal access token
git push -u origin main
  1. Después de realizar cualquier cambio, puedes confirmarlo y enviarlo a GitHub:
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Envía tu código con GitHub para computadoras

  1. Descarga tu código siguiendo las instrucciones de la sección anterior "Desarrollo local". laboratorio
  2. Instala GitHub Desktop, inícialo y accede
  3. Clona el repositorio que acabas de crear

cf7f38c7c86a91cd.png

  1. Abre el explorador de archivos y copia tu proyecto en el nuevo repositorio.
  2. Confirma los cambios

5f3c1552e30ad7c5.png

  1. Publica tu rama principal en GitHub

Configura la implementación continua de Cloud Run

Con la configuración de SCM en GitHub, ahora puedes configurar la entrega continua para que cada vez que se envíen nuevas confirmaciones a la rama main, Cloud Build compilará e implementará automáticamente los cambios. También puedes agregar la integración continua, que ejecuta tus pruebas antes de la implementación, pero ese paso se dejó como ejercicio para ti, ya que los ejemplos listos para usar no contienen ninguna prueba.

  1. En la consola de Cloud, ve a tu servicio de Cloud Run.
  2. Haz clic en el botón “CONFIGURAR LA IMPLEMENTACIÓN CONTINUA”. botón
  3. Cómo autenticar con GitHub y seleccionar el repositorio de tu microservicio

a3b5692f178869bc.png

  1. Selecciona tu repositorio de GitHub y establece la rama en ^main$

338f1c00f33d2f65.png

  1. Configura el tipo de compilación para usar Buildpacks
  2. Haz clic en Guardar para configurar la implementación continua.

8. Observabilidad

Las cosas se rompen. La observabilidad nos permite saber cuándo ocurre eso y diagnosticar el motivo. Las métricas muestran datos sobre el estado y el uso de nuestro servicio. En los registros, se muestra la información instrumentada manualmente que emite nuestro servicio. Las alertas nos permiten recibir notificaciones cuando algo sale mal. Exploremos cada uno de ellos con más detalle.

Métricas

  1. Busca tu servicio en la lista de servicios de Cloud Run.
  2. Haz clic en el nombre de tu servicio para visitar el panel de métricas.

8491b8ec6bc5b4db.png

  1. Haz clic en el menú ⋮ en una métrica y, luego, selecciona "Ver en el Explorador de métricas"
  2. Ahora puedes cambiar las métricas de recursos, los filtros, la agrupación y otras opciones. Por ejemplo, puedes ver las latencias promedio del servicio de todos los servicios:

f0d666d8f4221d45.png

Registros

El resultado de STDOUT de los servicios se envía al sistema de Google Cloud Logging. Puedes acceder a una vista de registro básica desde la página de administración del servicio de Cloud Run, como la siguiente:

40058a82c9299cff.png

En los registros de Cloud Run, puedes filtrar por gravedad y filtrar los registros. Para obtener más flexibilidad, haz clic en: 186fdb0e6d39a6ca.png

Alertas

  1. Crea una URL de verificación de estado para tu servicio.
  2. Para Spring Boot, solo agrega la siguiente dependencia:
org.springframework.boot:spring-boot-starter-actuator
  1. Crea o actualiza el src/main/resources/application.properties y, luego, inhabilita la verificación de espacio en el disco:
management.health.diskspace.enabled=false
  1. Crea una alerta de tiempo de actividad y especifica tu protocolo, nombre de host y ruta de acceso. Para Spring Boot, la ruta es: /actuator/health
  2. Prueba la alerta

6948d13b263bf573.png

  1. Crea la alerta

9. Felicitaciones

¡Felicitaciones! Compilaste y, luego, implementaste con éxito un microservicio que puede combatir con otros microservicios. ¡Buena suerte!

Documentos de referencia