1. Introducción
Última actualización: 12 de febrero de 2020
Microservices Battle Arena
¿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? Si no es así, inténtalo algún día. Pero ahora, en lugar de arriesgarse a tener un golpe físico, 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. Y como estamos organizando esta primera batalla de microservicios en Atlanta, Georgia, nuestros microservicios lanzarán duraznos en lugar de bolas de nieve.
Tal vez te preguntes... Pero ¿cómo “arroja” un microservicio un durazno en 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 e implementar microservicios en Google Cloud.
Cómo funciona
Compilarás un microservicio con la tecnología que desees (o elegirás los activadores de Java, Kotlin o Scala) y, luego, lo implementarás en Google Cloud. Una vez implementado, deberás completar un formulario para 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. Para la conferencia DevNexus habrá un estadio para cada día. Cada jugador representa un microservicio que se mueve y lanza duraznos 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 durazno. Un durazno arrojado hasta tres espacios en la dirección hacia la que apunta el jugador. Si un durazno "choca" otro, el lanzador obtiene un punto y el jugador que batea pierde un punto. El tamaño de la arena se ajusta automáticamente para el número actual de jugadores.
Así se ve la arena con tres jugadores inventados:
Ejemplo de arena de combate Peach
Conflictos rotativos
En la arena, es posible que varios jugadores intenten realizar acciones contradictorias. Por ejemplo, dos jugadores podrían intentar moverse al mismo espacio. En caso de conflicto, prevalecerá el microservicio que tenga el tiempo de respuesta más rápido.
Mira la batalla
Para ver cómo le está yendo a tu microservicio en la batalla, consulta la arena en vivo.
API de Battle
Para trabajar con nuestro administrador de arena, tu microservicio deberá implementar una API específica para participar en el estadio. El administrador de la arena enviará el estado actual del estadio en una solicitud HTTP POST 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 ser 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 cualquiera de los siguientes:
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. 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. Para facilitar las cosas, puedes comenzar con un proyecto de muestra que solo elija un comando aleatorio.
Elija su muestra para comenzar
Puedes comenzar con los siguientes tres ejemplos de microservicios de batalla:
Java y Spring Boot | ||
Java y Quarkus | ||
Kotlin y Micronaut | ||
Kotlin y Quarkus | ||
Scala y Marco de trabajo de Play | ||
Go |
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
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.
Solicita la inclusión en la arena
Para poder participar en la arena, debes completar un formulario breve. Lo más difícil será determinar qué quieres usar como imagen de perfil. Puedes usar tu imagen de GitHub o LinkedIn, o elegiremos un avatar al azar por ti. Una vez que revisemos el envío, tu jugador aparecerá en la arena.
Marca y Implementa cambios
Para poder realizar cambios, debes configurar 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 del 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 comandos posteriores podamos especificar el directorio y el nombre del servicio correctos:
# Copy and paste ONLY ONE of these export SAMPLE=java-springboot export SAMPLE=kotlin-micronaut export SAMPLE=scala-play
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
A continuación, verás instrucciones adicionales para realizar cambios.
Cloud Shell con el editor y el proyecto de muestra abierto
Después de guardar 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).
pack build gcr.io/$PROJECT_ID/$SAMPLE \ --path cloudbowl-microservice-game/samples/$SAMPLE \ --builder heroku/buildpacks
Ahora que ya creaste la imagen de contenedor, usa el comando de Docker (en Cloud Shell) para enviarla a Google Container Registry y 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\
--memory=512Mi\
--allow-unauthenticated
Ahora el estadio usará tu nueva versión.
3. Felicitaciones
¡Felicitaciones! Compilaste y, luego, implementaste con éxito un microservicio que puede luchar con otros microservicios. ¡Buena suerte!
¿Qué sigue?
- Agrega seguimiento distribuido a tu app de Spring Boot
- Usa AI Platform para que tu microservicio sea superinteligente