Microservicios ASP.NET Core: aplicaciones que serán responsables de una única porción "vertical" de una arquitectura global de aplicaciones/servicios.
¿Por qué microservicios ASP.NET Core?
Hay muchos opiniones y recomendaciones sobre qué son los microservicios, cuándo utilizar microservicios frente a un monolito, y mucho más.
Microservicios pic.twitter.com/3xYWUgP2QW
- David Neal 🥓🥑 (@reverentgeek) 10 de julio de 2017
Este artículo no va a abordar esas cuestiones en su totalidad. En su lugar, sólo vamos a intentar caminar antes de volar.
Consideremos que estamos explorando arquitectura de microserviciosy queremos aprovechar la persistencia políglota para utilizar una base de datos NoSQL (Couchbase) para un caso de uso particular. Para nuestro proyecto, vamos a ver una Base de datos por servicio y utilizar Docker (docker-compose) para gestionar la base de datos de los microservicios de ASP.NET Core. prueba de concepto.
Esta entrada de blog utilizará Couchbase Server, pero puedes aplicar los conceptos básicos aquí a las otras bases de datos en tu arquitectura de microservicios también.
Estoy usando ASP.NET Core porque es un framework multiplataforma y de código abierto. Además, Visual Studio (aunque no es obligatorio) nos proporcionará algunas herramientas útiles para trabajar con Docker y docker-compose. Pero, de nuevo, puedes aplicar lo básico aquí a cualquier framework web o lenguaje de programación de tu elección.
Paso 1: Crear una nueva solución
Voy a utilizar Visual Studio para esta entrada del blog, pero se puede lograr el mismo efecto (con tal vez un poco más de trabajo) en Visual Studio Code o en la línea de comandos.
Cree un nuevo proyecto ASP.NET Core. He llamado al mío HelloMicroservice (y al el código fuente completo está disponible en GitHub para su referencia.
Para mi microservicio ASP.NET Core, también tomé estas decisiones en Visual Studio:
- Aplicación web MVC (Esto genera algo de HTML básico para fines de visualización, pero usted podría utilizar fácilmente un proyecto de API en su lugar)
- ASP.NET Core 3 (la última versión de ASP.NET Core en el momento de redactar este documento)
- Configurar para HTTPS (no es estrictamente necesario, pero es una buena idea)
- Activar la compatibilidad con Docker
En este punto, deberías tener un proyecto ASP.NET Core muy básico. A continuación, añadiremos algo de orquestación y una base de datos.
Paso 2: Añadir soporte para docker-compose
Haga clic con el botón derecho del ratón en proyectoy haga clic en "Añadir" y luego en "Soporte de Container Orchestrator".
Tenga en cuenta que el único propósito de este proyecto es iniciar el desarrollo de una prueba de concepto para ASP.NET Core Microservices. Docker-compose es más fácil de manejar que Kubernetes para el desarrollo en máquina local. Por eso elijo la opción "Docker Compose", aunque eventualmente quiera despliegue a Kubernetes.
También elegí Linux, porque es lo que espero desplegar más tarde.
Una vez completado este paso, se añadirá un elemento "docker-compose" a su solución.
Si echas un vistazo al archivo docker-compose.yml, verás que tiene un definido en él: hellomicroservice. Observe también que "Docker Compose" aparece ahora en la barra de herramientas de Visual Studio.
En este punto, puedes pulsar CTRL+F5 para ejecutar. Visual Studio utilizará Docker Compose para crear una imagen de tu proyecto y ejecutarla dentro de Docker. Tu navegador debería abrirse automáticamente, y verás la pantalla de "Bienvenida" estándar
Estamos progresando. Lo siguiente que tenemos que hacer es ejecutar una base de datos con docker-compose y hacer que nuestra aplicación ASP.NET Core se comunique con la base de datos. Una vez completados estos pasos, tendremos el shell mínimo de ASP.NET Core Microservices.
Paso 3: Añadir orquestación de base de datos a docker-compose
Couchbase hace imágenes de contenedores oficiales disponibles en Docker Hub. Para utilizar estas imágenes, vamos a añadir otro servicio bajo servicios: en el archivo docker-compose.yml:
|
1 2 3 4 5 6 7 |
servicios: couchbase: imagen: couchbase:empresa-6.0.3 volúmenes: - "./couchbase:/opt/couchbase/var" # carpeta local donde se almacenan los datos de couchbase puertos: - "8091:8091" # Permite el acceso local a la interfaz de usuario de gestión |
Lo básico que necesitas es:
couchbase:Esto inicia una definición de servicio llamada "couchbase" (puedes llamarlo de otra manera si lo deseas)imagen: couchbase:enterprise-6.0.3La imagen a utilizar para este servicio. Siempre es una buena idea ser explícito y utilizar una etiqueta como esta, de lo contrario puede por defecto a la "última" imagen, que no es necesariamente lo que quieres.puertos:Define qué número(s) de puerto exponer fuera de de Docker. Estoy exponiendo sólo 8091, porque ese es el número de puerto de Couchbase UI (ver también: Requisitos de red y cortafuegos)
En volúmenes: no es estrictamente necesario. Sin embargo, el uso de un volumen significa que incluso cuando la imagen couchbase deja de funcionar, los archivos de datos en /opt/couchbase/var se guardará en el ordenador host (el sistema de archivos de tu ordenador) y se podrá montar de nuevo la próxima vez que ejecutes la imagen. Esto significa que cualquier dato que pongas en couchbase seguirá ahí la próxima vez que ejecutes la imagen.
Si pulsa CTRL+F5 para ejecutar la aplicación, Docker Compose iniciará la orquestación, incluyendo ambos el hellomicroservice y la imagen couchbase. No tienen nada que ver entre sí (todavía) aparte de que se están ejecutando uno al lado del otro dentro de Docker. Si abres una línea de comandos y ejecutas docker psdeberías ver algo como esto:
|
1 2 3 4 5 |
PS C:\WINDOWS\sistema32> docker ps IMAGEN COMANDO CREADO ESTADO PUERTOS NOMBRES hellomicroservice:dev "tail -f…" 8 min… Arriba 8… 0.0.0.0... dockercompose1524…56534_hellomicroservice_1 couchbase:empresa-6.0.3 "/entryp…" 8 min… Arriba 8… 8092-8096... dockercompose1524…56534_couchbase_1 PS C:\WINDOWS\sistema32> |
(He truncado mucho el texto anterior para que quepa la información pertinente en el ancho de esta entrada de blog).
Paso 4: Cambios en la configuración
Porque he utilizado el stock couchbase:empresa-6.0.3 Docker, todavía tengo que abrir la interfaz de usuario de Couchbase (http://localhost:8091) y configurar el clúster manualmente. Ver "próximos pasos" al final para algunas opciones para automatizar.
Hay mucha documentación para guiarle en este procesoasí que no lo repetiré aquí. Observaré que estoy utilizando las credenciales "Administrador" y "contraseña". También he creado un cubo llamado hellomicroservice.
Una vez creado el bucket, el siguiente paso es hacer que la aplicación ASP.NET Core se comunique con la base de datos. Abra docker-compose.yml y actualice el archivo hellomicroservices: definición a:
|
1 2 3 4 5 6 7 8 9 10 |
hellomicroservice: imagen: ${REGISTRO_DOCKER-}hellomicroservice construya: contexto: . archivo docker: HolaMicroservicio/Dockerfile medio ambiente: Couchbase__Servidores__0: http://couchbase:8091/ # Referencia al nombre del servicio "couchbase" en la línea 4 depende_de: - couchbase # Referencia al nombre de servicio "couchbase" en la línea 4 comando: ["./wait-for-it.sh", "http://couchbase:8091"] |
Desglosemos cada una de estas partes:
medio ambiente:Esto le dice a docker-compose que cree variables de entorno.Couchbase__Servidores__0El nombre de una variable de entorno. El nombre aquí es importante. Esto se corresponderá con appsettings.json más tarde.http://couchbase:8091/La URL que ASP.NET Core necesitará para conectarse al servicio couchbase. Si nombró el servicio de otra manera que "couchbase", utilice ese nombre aquí también.depende_deAsí es como docker-compose sabrá en qué orden iniciar los servicios.comandoUn comando para ejecutar una vez que el servicio se inicia.
En este ejemplo, estoy utilizando espera-por-ello.shun script que esperará a que el host/puerto dado esté disponible. En la imagen Docker de Couchbase Server, Couchbase Server tardará unos segundos en iniciarse, así que este script esperará hasta que eso ocurra para proceder.
Por último, para que el proyecto ASP.NET Core se comunique con Couchbase, utilicé la función Extensión de la inyección de dependencia de NuGet:
|
1 |
servicios.AddCouchbase(Configuración.ObtenerSección("Couchbase")); |
Por defecto, la configuración se extraerá de appsettings.json. SIN EMBARGOrecuerde que una variable de entorno de Couchbase__Servidores__0 se define en docker-compose.yml. ASP.NET Core examinará las variables de entorno y anulará la configuración de las aplicaciones utilizando esos valores. Así que realmente no importa lo que valor está en appsettings.json (o appsettings.Development.json) para "Servidores":
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
{ "Registro": { "LogLevel": { "Por defecto": "Depurar", "Sistema": "Información", "Microsoft": "Información" } }, "Couchbase" : { "Nombre de usuario": "Administrador", "Contraseña": "contraseña", "Servidores" : ["http://thiswillbeoverwritten"] } } |
Sin embargo, el nombre de usuario y la contraseña se siguen leyendo de appsettings.
Paso 5: Utilizar la base de datos
Por último, vamos a asegurarnos de que la aplicación ASP.NET Core es capaz de comunicarse con la base de datos. He añadido un Inserte y Visite a la InicioControlador Índice método:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
público IActionResult Índice() { var id = Guía.NuevaGuid().ToString(); _bucket.Inserte(nuevo Documento<dinámico> { Id = id, Contenido = nuevo { hola = "microservicio", foo = Ruta.GetRandomFileName() } }); var doc = _bucket.Visite<dinámico>(id); devolver Ver(doc); } |
Algunos cambios correspondientes a la vista en Índice.cshtml:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
@modelo Couchbase.IOperationResultado<dinámico> @{ VerDatos["Título] = "Página de inicio"; } <div clase="texto-centro"> <h1 clase="display-4">Bienvenido</h1> <p>Aprenda acerca de <a href="https://docs.microsoft.com/aspnet/core">edificio Web aplicaciones con ASP.NET Núcleo</a>.</p> </div> <p>Creado a nuevo documento:</p> <ul> <li>ID: @Modelo.Id</li> <li>Documento: @Modelo.Valor</li> </ul> |
Y ahora, tenemos los fundamentos de ASP.NET Core Microservices en su lugar. Pulsa CTRL+F5 para ejecutar el servicio. Cuando se abra el navegador, deberías ver algo como esto:
Si en lugar de eso ves un mensaje de error, asegúrate de que has configurado Couchbase Server correctamente, has creado un bucket con el nombre correcto, has utilizado las credenciales de inicio de sesión correctas en appsettings.json y asegúrate de que tu docker-compose.yml coincide con los ejemplos anteriores.
Próximos pasos
Ahora puede desarrollar sus microservicios ASP.NET Core. Como desarrollador, la imagen Docker de su aplicación ASP.NET Core será su producto final. Dependiendo de dónde/cómo su organización planea desplegar, sus próximos pasos variarán mucho.
Esto es sólo el principio, pero aquí tienes más cosas que deberías explorar:
Volúmenes. Cierra Visual Studio por completo. Después de unos segundos, las imágenes Docker desaparecerán (intente docker ps de nuevo para verificarlo). Ahora, abre Visual Studio y CTRL+F5 de nuevo. Como hemos usado un volumen, los datos que almacenaste en Couchbase deberían seguir ahí. Si esto es lo que quieres para el desarrollo, estás en buena forma.
Automatización. Si prefieres que los datos se borren y se regeneren cada vez, tendrás que mirar de crear una imagen Docker personalizada. También puedes consultar la excelente proyecto couchbasefakeitque incluye una serie de herramientas, variables, scripts, etc, para inicializar Couchbase Server y poblarlo con índices y datos falsos. Puedes ver un ejemplo de esto en Gist que Brant Burnett compartió conmigo.
Kubernetes. Si planea desplegar Couchbase Server (o cualquier base de datos) en contenedores, es probable que desee consultar Kubernetes y Operadores de Kubernetesque facilitan la gestión de bases de datos en clústeres Kubernetes. Muchos proveedores de bases de datos han creado Operadores Kubernetes, y Couchbase fue el primer proveedor NoSQL en lanzar un Operador Kubernetes. Operador autónomo de Kubernetes.
Agradecimientos especiales
Esta entrada de blog no habría sido posible sin la tremenda ayuda de la Comunidad Couchbase.
Gracias a Brant Burnett por compartir conmigo el proceso de desarrollo de microservicios de su empresa.
Gracias a Calvin Allen por trabajar conmigo en este proceso en mi Codificación en directo en Twitch y para introduciéndome en wait-for-it.
