ASP.NET Core Kubernetes tutorial será cubierto en esta entrada del blog, como un seguimiento de ASP.NET Core Microservicios: Primeros pasos.
Acabo de ver esto y me ha hecho reír MUCHO MÁS de lo que debería. pic.twitter.com/R1wleGZM0B
- Carmen Crincoli - @crincoli.org (@CarmenCrincoli) 6 de agosto de 2019
En la entrada anterior, se creó un microservicio ASP.NET Core con Couchbase utilizando docker-compose para fines de desarrollo y despliegue local. Una vez listos para la producción, los servicios suelen desplegarse en servicios gestionados de Kubernetes como AKS, EKS, GKEetc.
Este tutorial de ASP.NET Core Kubernetes contiene algunos pasos que son específicos de Azure AKS, pero la mayor parte de este material se puede aplicar a cualquier clúster Kubernetes.
ASP.NET Core Kubernetes Tutorial general
En este tutorial de ASP.NET Core Kubernetes, recorreré estos pasos:
- Crea una imagen Docker y envíala al hub Docker
- Crear un clúster AKS en Azure
- Despliegue de un microservicio ASP.NET Core en AKS
- Despliega Couchbase Server en él usando un operador Kubernetes
Además, voy a cubrir algunos temas opcionales, pero muy útiles:
- Uso de DNS SRV para permitir que el microservicio ASP.NET Core localice su base de datos
- Configuración del reenvío de puertos con kubectl para obtener acceso por túnel a los pods AKS
- Visualización del panel de control de Kubernetes en AKS
- Configuración de un servicio Load Balancer en Kubernetes para exponer el microservicio ASP.NET Core a Internet.
Requisitos previos para aprovechar al máximo este tutorial:
- Docker instalado, algunos conocimientos básicos de Docker y Docker Hub
- Visual Studio instalado, aunque no es estrictamente necesario.
- Una cuenta Azure (si no tiene una, puede regístrate ahora y consigue $200 en crédito de forma gratuita). Si desea utilizar EKS, GKE, etc, todavía se puede seguir a lo largo de este tutorial, pero tendrá que sustituir algunos pasos por su cuenta.
- kubectl (para Kubernetes) instalado
Crear imagen Docker
Los despliegues de Kubernetes utilizan imágenes de contenedores. Existen muchas opciones de registros de contenedores privados (como Registro de contenedores Azure), pero para mantener las cosas simples para este tutorial, voy a utilizar viejo llano Centro Docker.
En primer lugar, empezaré por crear una imagen Docker a partir del microservicio ASP.NET Core que creé en la entrada anterior. Desde Visual Studio, esto es tan fácil como hacer clic con el botón derecho en Dockerfile y seleccionar "Build Docker Image".
Una vez construida la imagen, aparecerá en tu repositorio local de imágenes Docker. Puedes ver este repositorio desde la línea de comandos utilizando "docker images":
|
1 2 3 4 |
PS C:\Usuarios\mgroves> docker imágenes REPOSITORIO TAG IMAGEN ID CREADO TALLA mattgroves/hellomicroservice última b2387e47a826 3 semanas hace 213MB hellomicroservice última b2387e47a826 3 semanas hace 213MB |
El siguiente paso es empujar esta imagen a Docker hub (por favor, revise si usted no ha utilizado Docker Hub antes). Empujé mi imagen a Docker con el comando docker push mattgroves/hellomicroservice comando. Lo más probable es que desee etiquetar sus imágenes con números de versión para asegurarse de que Kubernetes está tirando de la versión exacta que desea implementar.
Si quieres saltarte este paso, puedes usar mi imagen Docker como ejemplo: mattgroves/hellomicroservice.
Escribir archivos YAML para el despliegue
Ahora que has publicado una imagen Docker, podemos empezar a escribir los archivos YAML para un despliegue Kubernetes. Este tutorial no cubrirá todo lo que hay que saber sobre Kubernetes, pero señalará las secciones dignas de mención tanto como sea posible. Para este tutorial, habrá tres archivos YAML en total creados para estar junto con los archivos YAML que se envían con el Operador Couchbase.
Cada uno de estos archivos YAML corresponde a un recurso de Kubernetes. Kubernetes orquestará el clúster en función de los recursos que cree en el clúster.
El recurso ASP.NET Core Microservice y el recurso Couchbase Cluster darán lugar cada uno a uno o varios "vainas" que se están creando en el clúster Kubernetes. Otros tipos de recursos son "secretos" (para gestionar y almacenar información sensible) y "servicios" (para exponer un conjunto de vainas), y muchos otros.
ASP.NET Core Microservicio
Empecemos por crear un archivo YAML para el propio despliegue del microservicio ASP.NET Core:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
apiVersion: aplicaciones/v1beta1 # para versiones anteriores a la 1.8.0 utilice apps/v1beta1 amable: Despliegue metadatos: nombre: hola-microservicio-aplicación-despliegue spec: selector: matchLabels: aplicación: hola-microservicio-aplicación réplicas: 1 # indica al despliegue que ejecute pods # que coincidan con la plantilla plantilla: # crear pods utilizando la definición de pod de esta plantilla metadatos: etiquetas: aplicación: hola-microservicio-aplicación spec: contenedores: - nombre: hola-microservicio-aplicación imagen: mattgroves/hellomicroservice imagePullPolicy: Siempre puertos: - containerPort: 80 nombre: servidor env: - nombre: Couchbase__Nombre de usuario valorDesde: secretKeyRef: nombre: cb-hellomicroservices-auth clave: nombre de usuario - nombre: Couchbase__Contraseña valorDesde: secretKeyRef: nombre: cb-hellomicroservices-auth clave: contraseña - nombre: Couchbase__ConexionString valor: couchbase://cb-hellomicroservices-srv recursos: solicita: cpu: 100m memoria: 128Mi límites: cpu: 250m memoria: 256Mi |
Notas sobre hello-microservice.yaml:
réplicas.spec: Indica a Kubernetes cuántos pods de este servicio debe crear. Para empezar, 1 está bien, pero a medida que escale, necesitará más pods (y probablemente un LoadBalancer, que se tratará más adelante).spec.template.spec.containers.image: Esto le dice a Kubernetes qué imágenes utilizar. En mi caso, mattgroves/hellomicroservice es la que se construyó anteriormente en este tutorial y se desplegó en el hub de Docker.env: Definen variables de entorno para cada contenedor. En lugar de codificar estas credenciales en la imagen, estoy pasando un nombre de usuario, contraseña y ConnectionString al microservicio ASP.NET Core, al igual que se hizo en la entrada del blog anterior. Más sobre Couchbase__ConnectionString y DNS SRV más adelante.- También puede utilizar "service.namespace" si el clúster Couchbase vive en otro espacio de nombres.
Clúster Couchbase
A continuación, se muestra un archivo YAML para la base de datos, que utiliza el método Operador Couchbase Kubernetes:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
apiVersion: couchbase.com/v1 amable: CouchbaseCluster metadatos: nombre: cb-hellomicroservices spec: baseImage: couchbase versión: 6.5.0-beta2 authSecret: cb-hellomicroservices-auth exposeAdminConsole: verdadero adminConsoleServices: - datos grupo: dataServiceMemoryQuota: 256 indexServiceMemoryQuota: 256 searchServiceMemoryQuota: 256 eventingServiceMemoryQuota: 256 analyticsServiceMemoryQuota: 1024 indexStorageSetting: plasma autoFailoverTimeout: 30 autoFailoverMaxCount: 3 autoFailoverOnDataDiskIssues: verdadero autoFailoverOnDataDiskIssuesTimePeriod: 30 autoFailoverServerGroup: falso cubos: - nombre: hellomicroservice tipo: couchbase memoryQuota: 256 réplicas: 0 ioPriority: alta política de desalojo: fullEviction resolución de conflictos: seqno enableFlush: falso enableIndexReplica: falso servidores: - talla: 1 nombre: todos_servicios servicios: - datos - índice - consulta |
Este archivo YAML por sí mismo no es suficiente para utilizar el Operador, pero la instalación del Operador vendrá más adelante en este tutorial. Ten en cuenta también que, aunque el patrón Operator es una forma cada vez más común y eficaz de gestionar software con estado en Kubernetes, el YAML variará en función de la base de datos que estés utilizando (es decir, este YAML solo funcionará para Couchbase Server).
Notas sobre couchbase-cluster.yaml:
versión.specEsto especifica que imagen de contenedor Couchbase usar. Estoy usando la versión beta2. En el momento de escribir esto, el operador sólo funciona con la versión Enterprise. Esto puede cambiar pronto.spec.cluster,cubos.spec,servidores.spec: definen varias configuraciones para el cluster de Couchbase Server. Por favor consulte la documentación para obtener la lista completa de ajustes. Este archivo de ejemplo sólo cubre un puñado.
Los "secretos" de Couchbase
También he creado un recurso "secreto". Los secretos son donde la información de configuración como credenciales, contraseñas, tokens de autorización, etc, se pueden almacenar y gestionar con la propia API de Kubernetes.
|
1 2 3 4 5 6 7 8 |
apiVersion: v1 amable: Secreto metadatos: nombre: cb-hellomicroservices-auth tipo: Opaco datos: nombre de usuario: QWRtaW5pc3RyYXRvcg== Administrador # contraseña: cGFzc3dvcmQ= Contraseña # |
Este secreto contiene las credenciales que quiero que use Couchbase (así como el microservicio ASP.NET Core). Los valores están codificados en base64 (valores reales en los comentarios). Estas credenciales de ejemplo NO son suficientes para un despliegue real: por favor, cámbialas por algo más difícil de adivinar.
Tenga en cuenta la metadata.name es "cb-hellomicroservices-auth". Consulta hello-microservice.yaml y couchbase-cluster.yaml para ver cómo se hace referencia a estos secretos.
DNS SRV
Vuelve a mirar hello-microservice.yaml. En envObserva el par nombre/valor de "Couchbase__ConnectionString" y "couchbase://cb-hellomicroservices-srv". En lugar de dar a ASP.NET Core la dirección IP o URL de los nodos de Couchbase Server, estoy utilizando una cadena de conexión para dirigirlo a un Entrada DNS SRV.
En un Cluster de Couchbase, los pods que ejecutan Couchbase tienen el potencial de cambiar sus nombres de forma regular. Por lo tanto, se recomienda utilizar DNS SRV para localizar el servicio Couchbase. Afortunadamente, el Operador Autónomo de Couchbase crea una entrada DNS SRV para nosotros automáticamente.
Pronto podremos verlo en el Dashboard de Kubernetes, pero mientras tanto, sólo ten en cuenta que será el nombre del Cluster de Couchbase más "-srv". Así que en nuestro caso, es "cb-hellomicroservices-srv".
He realizado un pequeño cambio en el microservicio ASP.NET Core desde la anterior entrada del blog: Ahora estoy usando el Couchbase.Extensions.DnsDiscovery biblioteca.
Además de añadir esta librería desde NuGet, y usar ConnectionString en lugar de Server en appsettings.json, el único otro cambio que hay que hacer es AddCouchbaseDnsDiscovery dentro del ConfigureServices método.
|
1 2 |
servicios.AddCouchbase(Configuración.ObtenerSección("Couchbase")); servicios.AddCouchbaseDnsDiscovery(); |
Así de fácil. Para más información sobre DNS SRV, consulte Registros SRV en la documentación de Kubernetes.
Despliegue en AKS
En este punto, estamos listos para desplegar en AKS. Para revisar, aquí están los ingredientes que tenemos hasta ahora:
- Imagen Docker de ASP.NET Core en Docker Hub
- Archivo YAML para la implantación de ASP.NET Core
- Archivo YAML para el despliegue de Couchbase Cluster
- Archivo YAML para los secretos de Couchbase (referenciado por 2 y 3)
Para desplegar en AKS, seguí el procedimiento Inicio rápido: Despliegue de un clúster del servicio Azure Kubernetes mediante la CLI de Azure en la documentación de Microsoft. He aquí un breve resumen de los pasos que seguí:
(Si desea utilizar su línea de comandos local, asegúrese de que dispone de azure-cli instalado. De lo contrario, puede utilizar la función Shell de Azure Cloud).
En primer lugar, inicie sesión en Azure: az login. Se le pedirá que introduzca sus credenciales en su navegador web.
Una vez que haya iniciado sesión, cree primero un "grupo de recursos". Este es un grupo de organización dentro de Azure. Especifica un centro de datos (yo usé eastus).
az group create --name helloMicroserviceGroup --location eastus
A continuación, cree un clúster AKS utilizando el grupo de recursos que acaba de crear. Hay muchas opciones para esto. Para mantener este ejercicio relativamente barato y simple, elegí crear 3 nodos usando el tamaño Standard_B2s VM. Para despliegues de producción de Couchbase, es probable que necesites/quieras tamaños más potentes.
az aks create --resource-group helloMicroserviceGroup --name helloMicroserviceAks --node-count 3 --node-vm-size Standard_B2s --enable-addons monitoring --generate-ssh-keys
Este paso tardará algún tiempo en ejecutarse. Azure tardará unos 10 minutos en configurar este clúster AKS de Kubernetes.
Una vez creado el clúster, utilice obtener-credenciales para que kubectl sepa qué clúster utilizará.
az aks get-credentials --resource-group helloMicroserviceGroup --name helloMicroserviceAks
Llegados a este punto, es hora de crear algunos recursos de Kubernetes. Los seis primeros archivos YAML pueden descargarse en "Kubernetes" couchbase.com/descargas.
|
1 2 3 4 5 6 |
kubectl crear -f crd.yaml kubectl crear -f admisión.yaml kubectl crear -f operador-papel.yaml kubectl crear -f operador-servicio-cuenta.yaml kubectl crear -f operador-papel-vinculante.yaml kubectl crear -f operador-despliegue.yaml |
A continuación, utilice los tres archivos YAML que se crearon en este tutorial:
|
1 2 3 |
kubectl crear -f secreto.yaml kubectl crear -f couchbase-grupo.yaml kubectl crear -f hola-microservicio.yaml |
Para ver el estado de sus pods Kubernetes, utilice kubectl get pods. Los pods de Couchbase tardarán unos minutos en estar listos.
Reenvío de puertos
En la implementación anterior, ninguna de las implementaciones de Kubernetes está realmente expuesta fuera de Kubernetes. Una forma de asegurarnos de que el microservicio funciona es utilizar la función kubectl port-forward comando. Esto creará un "túnel" localhost al pod dado.
Por ejemplo, creemos un túnel desde el puerto localhost 5000 al microservicio ASP.NET Core que se ejecuta en el puerto 80:
kubectl port-forward 5000:80
En este punto, puede acceder al microservicio utilizando http://locahost:5000 en su navegador.
Del mismo modo, puede configurar un túnel para la interfaz de usuario integrada basada en web de Couchbase Server:
kubectl port-forward cb-hellomicroservices-0000 8091:8091
Y ahora puedes acceder al cluster de Couchbase usando http://localhost:8091.
El comando port-forward puede ser útil para desarrolladores y operaciones, pero sigue leyendo para ver cómo exponer un servicio de Kubernetes a Internet.
Exponer el servicio con el equilibrador de carga
Aunque el reenvío de puertos puede darnos acceso a pods fuera del clúster Kubernetes, ¿qué ocurre cuando los pods inevitablemente se bloquean, mueren y renacen con nuevas direcciones IP, nombres de pod, etc.? Kubernetes nos permite crear "servicios" para dirigirse lógicamente a uno o varios pods.
Un servicio puede especificarse en los archivos YAML, al igual que los despliegues.
También se puede crear un servicio utilizando kubectl exponer. Por ejemplo, puedo exponer un servicio de equilibrador de carga que proporcione acceso a cuantos pods ASP.NET Core haya creado mi despliegue:
kubectl expose deployments hello-microservice-app-deployment --port=80 --type=LoadBalancer
Cuando se cree el servicio, se creará una dirección IP externa. Puede ver la información del servicio con kubectl obtener servicios.
|
1 2 3 4 5 6 7 8 |
PS C:\Usuarios\mgroves> kubectl consiga servicios NOMBRE TIPO CLÚSTER-IP EXTERNO-IP PUERTO(S) EDAD cb-hellomicroservice ClusterIP Ninguno <ninguno> 8091/TCP,18091/TCP 17d cb-hellomicroservice-srv ClusterIP Ninguno <ninguno> 11210/TCP,11207/TCP 17d cb-hellomicroservice-ui PuertoNodo 10.0.194.12 <ninguno> 8091:30624/TCP,18091:31169/TCP 17d couchbase-operador-admisión ClusterIP 10.0.218.95 <ninguno> 443/TCP 17d kubernetes ClusterIP 10.0.0.1 <ninguno> 443/TCP 17d hola-microservicio-aplicación-despliegue LoadBalancer 10.0.6.87 20.NN.NN.21 80:32710/TCP 13s |
Abra esa dirección IP en un navegador web (20.NN.NN.21 en mi ejemplo), y será la carga de acceso equilibrado a los pods en su despliegue. A medida que aumenta o disminuye la escala (es decir, cambia el número de réplicas), el servicio seguirá siendo el mismo y continuará proporcionando acceso.
Cuadro de mandos de Kubernetes
Kubernetes tiene su propio panel de control de interfaz de usuario que puede ser útil para obtener una visualización de la imagen completa sin tener que recordar un montón de comandos de líneas de comandos. Para acceder a la Cuadro de mandos de Kubernetes para AKS:
Cree un ClusterRoleBinding para el panel de control de Kubernetes para habilitar el acceso:
kubectl create clusterrolebinding kubernetes-dashboard --clusterrole=cluster-admin --serviceaccount=kube-system:kubernetes-dashboard
A continuación, utilice Azure's aks browse para iniciar el cuadro de mandos:
az aks browse --resource-group helloMicroserviceGroup --name helloMicroserviceAks
Esto también debería activar automáticamente su navegador web para abrir el panel de control:
Desde el panel de control, puede ver todos los pods, servicios, secretos, nodos y mucho más.
Próximos pasos
Si has estado siguiendo AKS, no olvides eliminar el grupo de recursos cuando hayas terminado. De lo contrario, continuará ejecutándose en tu cuenta Azure y te cobrará por el tiempo de computación. Puedes eliminar todo el grupo de recursos de este tutorial con un solo comando:
az group delete --name helloMicroserviceGroup
Había un montón de terreno cubierto en este tutorial ASP.NET Core Kubernetes, pero espero que suficiente para apuntar en la dirección correcta y empezar con un "Hola, mundo" ejemplo.
Al igual que en la última entrada del blog, este tutorial de ASP.NET Core Kubernetes es producto de un par de streams de codificación en directo en Twitch. Puedes ver parte 1 y parte 2 en YouTube. Y si tienes preguntas, puedes pasarte por el retransmisión en directo en Twitch la próxima vez y ¡a charlar!
Kubernetes es un tema muy amplio. Hay un montón de direcciones que usted podría ir de aquí. Aquí hay algunos enlaces que usted puede ser que desee comprobar hacia fuera:
-
Este tutorial utiliza la versión 1.2 del operador Couchbase Kubernetes. El YAML para la versión 2.0 (próximamente) será diferente.
-
De mi colega Denis Rosa, Microservicios en Kubernetes y la entrada de su blog sobre Creación de microservicios elásticos con Kubernetes y Spring Boot
-
En Kubernetes:
-
Conectar aplicaciones con serviciosque menciona LoadBalancer
-
Recordatorio de que este tutorial ASP.NET Core Kubernetes es un seguimiento de mi anterior post, link:https://www.couchbase.com/blog/asp-net-core-microservices-getting-started/
[ASP.NET Core Microservices: Getting Started]. Si aún no lo has leído, puede que te falte algo de contexto. -
Twilio también publicó un entrada de blog similar hace unos meses que utiliza el Azure Container Registry.
