1. Descripción general
ASP.NET Core es un nuevo marco de trabajo de código abierto y multiplataforma que sirve para compilar aplicaciones modernas basadas en la nube y conectadas a Internet a través del lenguaje de programación C#.
Kubernetes es un proyecto de código abierto que se puede ejecutar en muchos entornos distintos, desde laptops hasta clústeres de varios nodos de alta disponibilidad; desde nubes públicas hasta implementaciones locales; desde máquinas virtuales hasta equipos físicos.
En este lab, implementarás una aplicación simple de ASP.NET Core en Kubernetes, que se ejecuta en Kubernetes Engine. Este codelab se basa en el codelab Compila e inicia una app de ASP.NET Core desde Google Cloud Shell. Te recomendamos que realices ese lab primero antes de intentar hacer este.
El objetivo de este codelab es que conviertas tu código (en este caso, una aplicación Hello World simple de ASP.NET Core) en una aplicación replicada que se ejecute en Kubernetes. Convertirás el código que hayas desarrollado en tu máquina en una imagen de contenedor de Docker y, luego, la ejecutarás en Google Kubernetes Engine.
Este es un diagrama de las distintas partes que están en juego en este codelab. Lo ayudará a entender cómo encajan las piezas. Úselo como referencia a medida que avanza en el codelab. Todo debería tener sentido cuando llegue al final (pero puede ignorarlo por el momento).
A los fines de este codelab, utilizar un entorno administrado como Kubernetes Engine (una versión de Kubernetes alojada en Google que se ejecuta en Compute Engine) te permite concentrarte en experimentar con Kubernetes, en vez de configurar la infraestructura subyacente.
Si le interesa ejecutar Kubernetes en su máquina local, como una laptop de desarrollo, le recomendamos que obtenga información sobre Minikube. Esta herramienta ofrece una configuración sencilla de un clúster de Kubernetes de un solo nodo para fines de desarrollo y pruebas. Si lo deseas, puedes usar Minikube durante este codelab.
Qué aprenderás
- Cómo empaquetar una aplicación simple de ASP.NET Core como un contenedor de Docker
- Cómo crear tu clúster de Kubernetes en Google Kubernetes Engine (GKE)
- Cómo implementar su aplicación de ASP.NET Core en un pod
- Cómo permitir el tráfico externo en su pod
- Cómo escalar su servicio verticalmente e implementar una actualización
- Cómo ejecutar el panel gráfico de Kubernetes
Requisitos
¿Cómo usarás este instructivo?
¿Cómo calificarías tu experiencia con Google Cloud Platform?
2. Configuración y requisitos
Configuración del entorno de autoaprendizaje
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla en cualquier momento.
- El ID del proyecto debe ser único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID del proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usará el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no debería costar mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar todo el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de USD 300.
Inicia Cloud Shell
Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.
Activar Cloud Shell
- En la consola de Cloud, haz clic en Activar Cloud Shell
.
Si nunca has iniciado Cloud Shell, aparecerá una pantalla intermedia (mitad inferior de la página) en la que se describirá qué es. Si ese es el caso, haz clic en Continuar (y no volverás a verla). Así es como se ve la pantalla única:
El aprovisionamiento y la conexión a Cloud Shell solo tomará unos minutos.
Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitas. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Gran parte de tu trabajo en este codelab, si no todo, se puede hacer simplemente con un navegador o tu Chromebook.
Una vez conectado a Cloud Shell, debería ver que ya se autenticó y que el proyecto ya se configuró con tu ID del proyecto.
- En Cloud Shell, ejecuta el siguiente comando para confirmar que está autenticado:
gcloud auth list
Resultado del comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto:
gcloud config list project
Resultado del comando
[core] project = <PROJECT_ID>
De lo contrario, puedes configurarlo con el siguiente comando:
gcloud config set project <PROJECT_ID>
Resultado del comando
Updated property [core/project].
3. Cree una aplicación de ASP.NET Core en Cloud Shell
En el símbolo del sistema de Cloud Shell, puedes verificar que la herramienta de línea de comandos de dotnet ya esté instalada. Para ello, verifica su versión. Esto debería imprimir la versión de la herramienta de línea de comandos de dotnet instalada:
dotnet --version
A continuación, crea una nueva aplicación web de ASP.NET Core de base.
dotnet new mvc -o HelloWorldAspNetCore
Esto creará un proyecto y restablecerá sus dependencias. Deberías ver un mensaje similar al que se muestra a continuación.
Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.
Restore succeeded.
4. Ejecute la aplicación de ASP.NET Core
Ya está casi todo listo para ejecutar la app. Navega a la carpeta de la app.
cd HelloWorldAspNetCore
Por último, ejecuta la app.
dotnet run --urls=http://localhost:8080
La aplicación inicia la escucha en el puerto 8080.
Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.
Para verificar que se esté ejecutando la app, haz clic en el botón Vista previa en la Web, que se encuentra en la parte superior derecha de la pantalla, y selecciona “Vista previa en el puerto 8080”.
Verás la página web predeterminada de ASP.NET Core:
Una vez que verifiques que la app se está ejecutando, presiona Ctrl + C para detenerla.
5. Empaquete la aplicación de ASP.NET Core como un contenedor de Docker
A continuación, prepara tu app para que se ejecute como un contenedor. El primer paso es definir el contenedor y su contenido.
En el directorio base de la app, crea un Dockerfile para definir la imagen de Docker.
touch Dockerfile
Agrega lo siguiente a Dockerfile con tu editor favorito (vim, nano,emacs o el editor de código de Cloud Shell).
# Use Microsoft's official build .NET image. # https://hub.docker.com/_/microsoft-dotnet-core-sdk/ FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build WORKDIR /app # Install production dependencies. # Copy csproj and restore as distinct layers. COPY *.csproj ./ RUN dotnet restore # Copy local code to the container image. COPY . ./ WORKDIR /app # Build a release artifact. RUN dotnet publish -c Release -o out # Use Microsoft's official runtime .NET image. # https://hub.docker.com/_/microsoft-dotnet-core-aspnet/ FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime WORKDIR /app COPY --from=build /app/out ./ # Make sure the app binds to port 8080 ENV ASPNETCORE_URLS http://*:8080 # Run the web service on container startup. ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]
Una configuración importante incluida en su Dockerfile es el puerto que utiliza la aplicación para escuchar el tráfico entrante (8080). Para cumplir con ese requisito, se debe configurar la variable de entorno ASPNETCORE_URLS, que utilizan las aplicaciones de ASP.NET Core a fin de determinar el puerto que se debe escuchar.
Guarda este Dockerfile. Ahora, compilaremos la imagen:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Una vez que se complete este proceso (tardará un tiempo en descargar y extraer todo), podrás ver que la imagen se compiló y guardó de forma local:
docker images REPOSITORY TAG gcr.io/yourproject-XXXX/hello-dotnet v1
Prueba la imagen de forma local con el siguiente comando, que ejecutará un contenedor de Docker de forma local en el puerto 8080 desde la imagen de contenedor que creaste recientemente:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Nuevamente, aprovecha la función de vista previa en la Web de Cloud Shell :
Deberías ver la página web predeterminada de ASP.NET Core en una pestaña nueva.
Después de verificar que la app se ejecuta correctamente de forma local en un contenedor de Docker, puedes detener el contenedor en ejecución con Ctrl-> C.
Ahora que la imagen funciona como debe, puede enviarla a Google Container Registry, un repositorio privado para sus imágenes de Docker al que puede acceder desde cada proyecto de Google Cloud y también desde fuera de Google Cloud Platform:
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Si todo sale bien, después de un tiempo, deberías poder ver la imagen de contenedor en la sección Container Registry. Ahora tienes una imagen de Docker disponible para todo el proyecto, a la que Kubernetes puede acceder y que puede organizar, como verás en unos minutos.
Si deseas conocer más, puedes explorar las imágenes de contenedor almacenadas en Google Cloud Storage a través del siguiente vínculo: https://console.cloud.google.com/storage/browser/ (el vínculo final completo debe tener este formato: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).
6. Crea un clúster de Kubernetes
De acuerdo. Ahora puedes crear tu clúster de GKE, pero, antes de eso, navega a la sección Google Kubernetes Engine de la consola web y espera a que se inicialice el sistema (solo debería tardar unos segundos).
Un clúster consiste en un servidor de API de instancia principal de Kubernetes que administra Google y un conjunto de nodos trabajadores. Los nodos trabajadores son máquinas virtuales de Compute Engine.
Usemos la CLI de gcloud desde tu sesión de Cloud Shell para crear un clúster. Ajusta tu zona a un lugar cercano ( lista de zonas). Este proceso tardará unos minutos en completarse:
gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b
Cuando el proceso se complete, debería ver que se creó el clúster.
Creating cluster hello-dotnet-cluster...done. Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster]. kubeconfig entry generated for hello-dotnet-cluster. NAME ZONE MASTER_VERSION hello-dotnet-cluster europe-west1-b 1.10.7-gke.6
Ahora deberías tener un clúster de Kubernetes completamente funcional con la tecnología de Google Kubernetes Engine:
Llegó la hora de implementar su propia aplicación en contenedores en el clúster de Kubernetes. A partir de ahora, usarás la línea de comandos kubectl (que ya está configurada en tu entorno de Cloud Shell). Para el resto de este codelab, se requiere que la versión del cliente de Kubernetes y del servidor sea la 1.2 o una posterior. kubectl version te mostrará la versión actual del comando.
7. Crea una implementación
Un pod de Kubernetes es un grupo de contenedores unidos para fines administrativos y de redes. Puede tener uno o varios contenedores. Aquí, simplemente usarás un contenedor compilado con tu imagen de ASP.NET Core almacenada en tu registro privado de Container Registry. Entregará contenido en el puerto 8080.
Crea un archivo hello-dotnet.yaml con tu editor favorito (vim, nano,emacs o el editor de código de Cloud Shell) y define la implementación de Kubernetes para el pod:
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
run: hello-dotnet
name: hello-dotnet
namespace: default
spec:
replicas: 1
selector:
matchLabels:
run: hello-dotnet
template:
metadata:
labels:
run: hello-dotnet
spec:
containers:
- name: hello-dotnet
image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8080
Realiza la implementación en el espacio de nombres predeterminado con kubectl:
kubectl apply -f hello-dotnet.yaml
deployment.apps/hello-dotnet created
Como puedes ver, creaste un objeto Deployment. Las implementaciones son la forma recomendada para crear y escalar pods. Aquí, una nueva implementación administra una sola réplica de pod que ejecuta la imagen hello-dotnet:v1.
Para ver la implementación que acabas de crear, simplemente ejecuta el siguiente comando:
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-dotnet 1 1 1 1 37s
Para ver el pod creado por la implementación, ejecute este comando:
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-ztzrb 1/1 Running 0 57s
Ahora es un buen momento para revisar algunos comandos kubectl interesantes (ninguno de estos modificará el estado del clúster; la documentación completa está disponible aquí):
kubectl get pods kubectl cluster-info kubectl config view kubectl get events kubectl logs <pod-name>
En este punto, deberías tener tu contenedor ejecutándose bajo el control de Kubernetes, pero aún tienes que hacerlo accesible para otras personas.
8. Permite el tráfico externo
Según la configuración predeterminada, el Pod únicamente es accesible a través de su IP interna dentro del clúster. Para que se pueda acceder al contenedor hello-dotnet desde fuera de la red virtual de Kubernetes, tienes que exponer el pod como un servicio de Kubernetes.
Desde Cloud Shell, puedes exponer el pod a la Internet pública con el comando kubectl expose combinado con la marca --type="LoadBalancer". Esta marca es necesaria para crear una IP accesible de forma externa:
kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080
La marca utilizada en este comando especifica que se usará el balanceador de cargas provisto por la infraestructura subyacente (en este caso, el balanceador de cargas de Compute Engine). Tenga en cuenta que se expone la implementación, y no el pod directamente. Esto hará que el servicio resultante balancee la carga de tráfico en todos los Pods administrados por la implementación (en este caso, solo 1 Pod, pero luego podrás agregar más réplicas).
La instancia principal de Kubernetes crea el balanceador de cargas y las reglas de reenvío, las reglas de firewall y los grupos de destino de Compute Engine relacionados para que se pueda acceder al servicio completamente desde fuera de Google Cloud Platform.
Para encontrar la dirección IP accesible de forma pública del servicio, solo debes solicitar que kubectl muestre todos los servicios del clúster:
kubectl get services
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-dotnet 10.3.253.62 104.155.20.69 8080/TCP 1m kubernetes 10.3.240.1 <none> 443/TCP 5m
Observa que se muestran 2 direcciones IP para tu servicio, y ambas entregan contenido al puerto 8080. Una es la IP interna que solo es visible dentro de su red virtual de Cloud; la otra es la IP externa de balanceo de cargas. En este ejemplo, la dirección IP externa es 104.155.20.69.
Ahora deberías poder acceder al servicio dirigiendo tu navegador a esta dirección: http://<EXTERNAL_IP>:8080
En este punto, pasarse a los contenedores y a Kubernetes ya te brindó varios beneficios: no necesitas especificar en qué host ejecutar tu carga de trabajo y también te beneficias de la supervisión y el reinicio del servicio. Veamos qué otros beneficios puede brindarle su nueva infraestructura de Kubernetes.
9. Escale tu servicio
Una de las características avanzadas que ofrece Kubernetes es la gran facilidad para escalar tu aplicación. Supongamos que, de repente, necesitas más capacidad para tu aplicación. Simplemente puedes indicarle al controlador de replicación que administre una nueva cantidad de réplicas para tu Pod:
kubectl scale deployment hello-dotnet --replicas=4
kubectl get deployment NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE hello-dotnet 4 4 4 3 16m
kubectl get pods NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-g4azy 1/1 Running 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m hello-dotnet-714049816-sh812 1/1 Running 0 1m hello-dotnet-714049816-ztzrb 1/1 Running 0 16m
Observa el enfoque declarativo que usamos aquí: en vez de iniciar o detener nuevas instancias, debes declarar cuántas instancias deberían estar en ejecución constantemente. Los bucles de conciliación de Kubernetes simplemente se aseguran de que la realidad coincida con lo que solicitaste y, de ser necesario, ejecutan acciones.
Aquí tienes un diagrama que resume el estado de tu clúster de Kubernetes:
También puedes reducir la escala de tu servicio con mucha facilidad. A continuación, te mostramos cómo reducir la cantidad de Pods de 4 a 2.
kubectl scale deployment hello-dotnet --replicas=2
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-g4azy 1/1 Running 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m
10. Resistencia a las pruebas
Kubernetes (o, más específicamente, ReplicaSet) supervisa tus pods y, si algo anda mal con un pod y este deja de funcionar, crea uno nuevo de inmediato. Probemos esto y veamos cómo funciona.
Primero, obtén la lista de pods:
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-g4azy 1/1 Running 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m
Borra uno de los Pods pasando el nombre del Pod:
kubectl delete pod hello-dotnet-714049816-g4azy
Si vuelves a mirar la lista de pods, verás que se crea un pod nuevo y se ejecuta de inmediato:
kubectl get pods
NAME READY STATUS RESTARTS AGE hello-dotnet-714049816-abczy 1/1 ContainerCreating 0 1m hello-dotnet-714049816-rk0u6 1/1 Running 0 1m
11. Implementa una actualización para tu servicio
En algún momento, la aplicación que implementó en producción requerirá la corrección de errores o funciones adicionales. Veamos cómo es ese proceso.
Primero, modifiquemos la aplicación. Abre el editor de código desde Cloud Shell.
Navega a Index.cshtml en HelloWorldAspNetCore > Views > Home y actualiza uno de los mensajes del carrusel.
Busca la siguiente línea:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core
Y cámbielo a lo siguiente:
Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud
Guarda los cambios y, luego, regresa a Cloud Shell. Dentro de HelloWorldAspNetCore,, compila la imagen de Docker:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
Y envíalo a Container Registry:
docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2
Ahora está listo para que Kubernetes actualice sin problemas su controlador de replicación a una versión nueva de la aplicación. Para cambiar la etiqueta de la imagen de tu contenedor en ejecución, debes editar el hello-dotnet deployment existente y cambiar la imagen de gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 a gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.
Para ello, usarás el comando kubectl edit. Se abrirá un editor de texto que muestra la configuración yaml completa de la implementación. No es necesario que entiendas la configuración yaml completa en este momento. Por ahora, es suficiente que entiendas que, cuando actualizas el campo spec.template.spec.containers.image en la configuración, le estás indicando a la implementación que actualice los pods a fin de que usen la imagen nueva.
kubectl edit deployment hello-dotnet
# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
deployment.kubernetes.io/revision: "1"
creationTimestamp: 2017-01-06T10:05:28Z
generation: 3
labels:
run: hello-dotnet
name: hello-dotnet
namespace: default
resourceVersion: "151017"
selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
replicas: 4
selector:
matchLabels:
run: hello-dotnet
strategy:
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
type: RollingUpdate
template:
metadata:
creationTimestamp: null
labels:
run: hello-dotnet
spec:
containers:
- image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
imagePullPolicy: IfNotPresent
name: hello-dotnet
ports:
- containerPort: 8080
protocol: TCP
resources: {}
terminationMessagePath: /dev/termination-log
dnsPolicy: ClusterFirst
restartPolicy: Always
securityContext: {}
terminationGracePeriodSeconds: 30
Después de hacer el cambio, guarda y cierra el archivo (esto usa vi, así que presiona "Esc", escribe :wq y presiona la tecla "Intro").
deployment "hello-dotnet" edited
Esto actualiza la implementación con la imagen nueva, lo que hace que se creen nuevos Pods con la imagen nueva y que se borren los anteriores.
kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hello-dotnet 4 5 4 3 1h
Mientras esto se aplica, los usuarios de los servicios no deberían sufrir ninguna interrupción. Después de un breve período, comenzarán a acceder a la versión nueva de su aplicación.
Puedes encontrar más detalles sobre las actualizaciones progresivas en la documentación de Kubernetes.
Esperamos que, con estas funciones de implementación, escalamiento y actualización, esté de acuerdo en que, una vez que configure su entorno (en este caso, su clúster de GKE/Kubernetes), Kubernetes puede ayudarlo a enfocarse en su aplicación, en lugar de tener que administrar la infraestructura.
12. Cloud Build
Hasta ahora, hemos estado compilando contenedores con comandos de Docker normales (docker build…) y, luego, enviamos la imagen de forma manual a Container Registry de Google Cloud Platform. También es posible diferir ambos pasos al Cloud Build del servidor, que puede compilar y enviar la imagen del contenedor sin tener una instalación local de Docker.
Primero, habilita la API de Cloud Build en Administrador de APIs > Biblioteca. Busca Cloud Build y haz clic en API de Cloud Build:
Haz clic en Habilitar API si aún no está habilitada. Al final, deberías ver la API habilitada de la siguiente manera:
Una vez que se habilite la API de Cloud Build, puedes ejecutar el siguiente comando para compilar y enviar tu imagen desde el servicio de Container Builder:
$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3
La imagen se almacena automáticamente en Container Registry.
13. Ejecuta el panel gráfico de Kubernetes
En las versiones recientes de Kubernetes, se agregó una interfaz de usuario web gráfica (panel). Esta interfaz de usuario le permite comenzar rápidamente y habilita algunas de las funcionalidades que se encuentran en la CLI como un método más accesible y visible para interactuar con el sistema.
Para configurar el acceso al panel del clúster de Kubernetes, escribe los siguientes comandos en la ventana de Cloud Shell :
gcloud container clusters get-credentials hello-dotnet-cluster \
--zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}
kubectl proxy --port 8081
Luego, vuelve a usar la función de vista previa de Cloud Shell para dirigirte al puerto 8081:
Esto debería dirigirlo al extremo de la API. Es posible que aparezca una página con el mensaje "No autorizado", pero no te preocupes. Para llegar al panel, quita "?authuser=3" y reemplázalo por "/ui".
Disfrute del panel gráfico de Kubernetes y utilícelo a fin de implementar aplicaciones en contenedores, así como para supervisar y administrar sus clústeres.
Otra opción es acceder al panel desde una máquina local o de desarrollo siguiendo las instrucciones similares que se brindan cuando, desde la consola web, presiona el botón "Conectar" correspondiente al clúster que desea supervisar.
Cuando termines de usar el panel, puedes presionar Control + C para detener el proxy. Obtenga más información sobre el panel de Kubernetes mediante un recorrido por el panel.
14. Logging
Puedes usar el comando kubectl logs para recuperar los registros de un contenedor que se ejecuta dentro de Kubernetes. Cuando usas Google Kubernetes Engine para ejecutar clústeres de Kubernetes administrados, todos los registros se reenvían y almacenan automáticamente en Google Cloud Logging. Para ver todos los resultados de los registros de los Pods, navega a Stackdriver → Logging → Registros en la consola de Google Cloud:
Una vez que estés en la consola de Logging, puedes navegar a Contenedor de GKE para ver todos los registros recopilados de STDOUT:
Desde aquí, puedes exportar los registros a Google BigQuery para analizarlos más a fondo o configurar alertas basadas en registros. No podremos hacerlo durante el lab de hoy.
15. ¡Felicitaciones!
De esta manera, finaliza este simple codelab introductorio sobre ASP.NET Core y Kubernetes. Solo aprendimos los aspectos básicos de esta tecnología y lo invitamos a explorar más con sus propios pods, controladores de replicación y servicios. Además, puede comprobar los sondeos en funcionamiento (verificaciones de estado) y usar la API de Kubernetes directamente.
Limpia
Eso es todo. Es hora de limpiar los recursos usados (para reducir los costos y ser un buen ciudadano de la nube).
Borra la implementación (que también borra los Pods en ejecución) y el Service (que también borra tu balanceador de cargas externo):
Primero, borra el servicio y la implementación, lo que también borrará tu balanceador de cargas externo:
kubectl delete service,deployment hello-dotnet
service "hello-dotnet" deleted deployment "hello-dotnet" deleted
A continuación, borra el clúster:
gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b
The following clusters will be deleted. - [hello-dotnet-cluster] in [europe-west1-b] Do you want to continue (Y/n)? Y Deleting cluster hello-dotnet-cluster...done. Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].
Esto borra todas las instancias de Google Compute Engine que ejecutan el clúster.
Por último, borra el bucket de almacenamiento del registro de Docker que aloja tus imágenes:
gsutil ls
gs://artifacts.<PROJECT_ID>.appspot.com/
gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...
Por supuesto, también puedes borrar todo el proyecto, pero perderías cualquier configuración de facturación que hayas realizado (primero debes inhabilitar la facturación del proyecto). Además, borrar un proyecto solo detendrá la facturación una vez que finalice el ciclo de facturación actual.
Temas abordados
- Cómo empaquetar una aplicación simple de ASP.NET Core como un contenedor de Docker
- Cómo crear tu clúster de Kubernetes en Google Kubernetes Engine
- Cómo implementar su aplicación de ASP.NET Core en un pod
- Cómo permitir el tráfico externo en su pod
- Cómo escalar su servicio verticalmente e implementar una actualización
- Cómo ejecutar el panel gráfico de Kubernetes
Próximos pasos
- Obtenga más información sobre Kubernetes (http://kubernetes.io/).
- Obtenga más información sobre Windows en Google Cloud Platform.
- Obtenga más información sobre .NET en Google Cloud Platform.
- Obtenga más información sobre SQL Server en Google Cloud Platform.
- Obtenga más información sobre Cloud Tools for Visual Studio.
- Obtenga más información sobre Cloud Tools for PowerShell.
Licencia
Este trabajo cuenta con una licencia Atribución 2.0 Genérica de Creative Commons.