1. Introducción
Última actualización: 26/08/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. Dado que alojamos esta batalla sobre microservicios en SpringOne, nuestros microservicios arrojarán hojas en lugar de bolas de nieve.
Tal vez te preguntes... Pero ¿cómo “arroja” un microservicio 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 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. La conferencia SpringOne tendrá su propio estadio. Cada jugador representa un microservicio que se mueve y arroja hojas 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 una hoja. Una hoja arrojada se desplazará hasta tres espacios en la dirección hacia la que apunta el jugador. Si una hoja "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 para el número actual de jugadores.
Así se ve un estadio anterior:
Ejemplo de arena de Battle One
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. 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. Para facilitar las cosas, te ayudaremos a empezar con un servicio de muestra y a implementarlo en Cloud Run.
Elija su muestra para comenzar
Hay dos ejemplos de microservicios de batalla que puedes usar:
Java y Spring Boot | ||
Kotlin y Spring Boot |
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.
4. Solicita la inclusión en la arena
Para que te incluyamos en el estadio, debes enviar un mensaje al canal de Slack #3-sponsor-google-cloud con tu nombre, la URL del servicio de Cloud Run y, opcionalmente, tu nombre de usuario de GitHub para su avatar o foto de perfil. Una vez que validemos la información, tu jugador aparecerá en la arena.
5. 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-springboot
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, inicia la aplicación en Cloud Shell:
cd cloudbowl-microservice-game/samples/$SAMPLE ./mvnw spring-boot:run
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 esté todo 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).
pack build gcr.io/$PROJECT_ID/$SAMPLE \ --path ~/cloudbowl-microservice-game/samples/$SAMPLE \ --builder gcr.io/buildpacks/builder
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.
6. Desarrollo a nivel local
Puedes trabajar en tu proyecto de manera local con tu propio IDE; para ello, sigue estos pasos:
- [En Cloud Shell] Comprime la muestra con el comando siguiente:
cd ~/cloudbowl-microservice-game/samples; zip -r cloudbowl-sample.zip $SAMPLE
- [En Cloud Shell] Descarga el archivo ZIP en tu máquina:
cloudshell download-file cloudbowl-sample.zip
- [En tu máquina] Descomprime el archivo, crea y prueba tus cambios
- [En tu máquina] Instala gcloud CLI
- [En tu máquina] Accede a Google Cloud:
gcloud auth login
- [En tu máquina] Configura las variables de entorno
PROJECT_IDySAMPLEcon los mismos valores que en Cloud Shell. - [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
- [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 --memory=512Mi --allow-unauthenticated
7. Felicitaciones
¡Felicitaciones! Compilaste y, luego, implementaste con éxito un microservicio que puede luchar con otros microservicios. ¡Buena suerte!
Seguir aprendiendo
Documentos de referencia
8. Preguntas frecuentes
¿Por qué mi microservicio no aparece en el campo?