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 Cómo compilar e iniciar una app de ASP.NET Core desde Google Cloud Shell. Recomendamos realizar ese lab antes de realizar este.
El objetivo de este codelab es que conviertas tu código (en este caso, una app de Hello World simple de ASP.NET Core) en una aplicación replicada que se ejecute en Kubernetes. Toma el código que desarrollaste en tu máquina, lo conviertes en una imagen de contenedor de Docker y, luego, ejecutas esa imagen en Google Kubernetes Engine.
A continuación, se muestra un diagrama de las distintas partes que están en juego en este codelab para ayudarte a comprender cómo encajan las piezas. Usa esto como referencia a medida que avances en el codelab. Todo debería tener sentido cuando llegues al final (pero puedes ignorarlo por ahora).
A los efectos de este codelab, usar un entorno administrado como Kubernetes Engine (una versión de Kubernetes alojada en Google que se ejecuta en Compute Engine) te permite enfocarte más en experimentar Kubernetes en lugar 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 para realizar 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 te importa qué es. En la mayoría de los codelabs, deberás hacer referencia al ID del proyecto (por lo general, se identifica como
PROJECT_ID). Si no te gusta el ID generado, puedes generar otro aleatorio. También puedes probar el tuyo propio y ver si está disponible. No se puede cambiar después de este paso y se mantendrá mientras dure el proyecto. - Para tu información, 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 te facture 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 iniciaste Cloud Shell, aparecerá una pantalla intermedia (mitad inferior de la página) que describe en qué consiste. Si ese es el caso, haz clic en Continuar (y no volverás a verlo). 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`
- Ejecuta el siguiente comando en Cloud Shell para confirmar que el comando de 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 comprobar que la herramienta de línea de comandos dotnet ya esté instalada revisando su versión. Esto debería imprimir la versión de la herramienta de línea de comandos 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 nuestra aplicación. 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 la app se esté ejecutando, haz clic en el botón Vista previa en la Web, que se encuentra en la parte superior derecha, y selecciona "Vista previa en el puerto 8080".
Verás la página web predeterminada de ASP.NET Core:
Una vez que hayas verificado que la aplicación se está ejecutando, presiona Ctrl + C para cerrarla.
5. Empaquete la aplicación de ASP.NET Core como un contenedor de Docker
A continuación, prepara la app para que se ejecute como 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 ello, se debe configurar la variable de entorno ASPNETCORE_URLS, que las aplicaciones de ASP.NET Core usan para determinar qué puerto escuchar.
Guarda este Dockerfile. Ahora, compilemos la imagen:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .
Una vez que se complete este proceso (la descarga y extracción tardará un poco en completarse), podrás ver que la imagen se compiló y se guardó de forma local:
docker images REPOSITORY TAG gcr.io/yourproject-XXXX/hello-dotnet v1
Prueba la imagen localmente con el siguiente comando, que ejecutará un contenedor de Docker localmente en el puerto 8080 desde la imagen de contenedor recién creada:
docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1
Y, nuevamente, aprovecha la función de vista previa en la Web de Cloud Shell :
Debería ver la página web predeterminada de ASP.NET Core en una pestaña nueva.
Una vez que hayas verificado que la app se ejecuta correctamente de manera local en un contenedor de Docker, puedes detener el contenedor en ejecución antes del 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 va bien después de un tiempo, deberías poder ver la imagen de contenedor en la sección Container Registry. En este punto, ya tienes disponible una imagen de Docker para todo el proyecto a la que Kubernetes puede acceder y organizar, como verás en unos minutos.
Si desea conocer más, puede navegar por las imágenes de contenedores almacenadas en Google Cloud Storage en este vínculo: https://console.cloud.google.com/storage/browser/ (el vínculo completo debe tener el siguiente formato: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).
6. Crea un clúster de Kubernetes
Ya está todo listo para 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 de tu sesión de Cloud Shell para crear un clúster. Ajusta la zona a un lugar cercano ( la 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 de kubectl (que ya está configurada en tu entorno de Cloud Shell). En el resto de este codelab, se requiere que tanto el cliente de Kubernetes como la versión del servidor sean la versión 1.2 o posterior. kubectl version te mostrará la versión actual del comando.
7. Crear 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 Container Registry privado. 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
Implementa 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 lo siguiente:
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 ejecutar algunos comandos kubectl interesantes (ninguno de estos cambiará 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 ejecutar tu contenedor bajo el control de Kubernetes, pero debes hacerlo accesible para todo el mundo.
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 de hello-dotnet desde fuera de la red virtual de Kubernetes, debes 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 conocer la dirección IP de acceso público del servicio, solo debes solicitar a kubectl que enumere 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
Ten en cuenta 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 si diriges el navegador a esta dirección: http://<EXTERNAL_IP>:8080
En este punto, obtuviste al menos varias funciones tras migrar a contenedores y Kubernetes. No necesitas especificar en qué host ejecutarás tu carga de trabajo; además, te beneficias de la supervisión y el reinicio del servicio. Veamos qué otros beneficios puede brindarle su nueva infraestructura de Kubernetes.
9. Escala 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. 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
Ten en cuenta el enfoque declarativo que se aplica aquí: en lugar de iniciar o detener instancias nuevas, declaras cuántas instancias deberían estar en ejecución en todo momento. Los bucles de conciliación de Kubernetes simplemente se aseguran de que la realidad coincida con lo que solicitó y, de ser necesario, toman medidas.
Aquí tienes un diagrama que resume el estado de tu clúster de Kubernetes:
También puedes reducir la escala verticalmente de tu servicio con mucha facilidad. Así es como podrías reducir la escala verticalmente de 4 Pods a 2 Pods.
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. Prueba la resiliencia
Kubernetes (o, más específicamente, ReplicaSet) supervisa tus Pods y, si hay algún problema con el Pod y este se interrumpe, 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 observas la lista de Pods nuevamente, verás que se crea un Pod nuevo que se vuelve a ejecutar 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 de 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. En HelloWorldAspNetCore,, compila la imagen de Docker:
docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 .
Enviarlo 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 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. Esto abrirá un editor de texto que mostrará la configuración yaml completa de la implementación. No es necesario entender toda la configuración de YAML en este momento, sino que, cuando se actualiza el campo spec.template.spec.containers.image en la configuración, le indicas a la implementación que actualice los Pods para usar la nueva imagen.
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" y, luego, escribe :wq y presiona la tecla "Intro").
deployment "hello-dotnet" edited
Esto actualiza el Deployment con la imagen nueva, lo que causa que se creen Pods nuevos 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.
Con estas funciones de implementación, escalamiento y actualización, estarás de acuerdo en que, una vez que configures tu entorno (aquí el clúster de GKE/Kubernetes), Kubernetes puede ayudarte a enfocarte en tu aplicación, en lugar de administrar la infraestructura.
12. Cloud Build
Hasta ahora, compilamos contenedores con comandos normales de Docker (docker build ...) y, luego, enviamos manualmente la imagen a Container Registry de Google Cloud Platform. También es posible diferir ambos pasos al servidor de Cloud Build, que puede compilar y enviar la imagen de contenedor sin tener que instalar Docker de forma local.
Primero, habilita la API de Cloud Build en Administrador de API > Biblioteca. Busca Cloud Build y haz clic en API de Cloud Build:
Haz clic en Habilitar API si aún no está habilitada. Cuando termines, deberías ver que la API está habilitada de la siguiente manera:
Una vez que se habilita 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, desde la ventana de Cloud Shell, escribe estos comandos :
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 recibas el mensaje "No autorizado" pero no te preocupes por eso. Para acceder 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.
También puede acceder al panel desde una máquina local o de desarrollo con instrucciones similares a las que se proporcionan cuando presiona "Conectar" en la consola web. del clúster que quieres 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 utilizas Google Kubernetes Engine para ejecutar clústeres de Kubernetes administrados, todos los registros se reenvían automáticamente y se almacenan en Google Cloud Logging. Para ver todos los resultados del registro de los Pods, navega a Stackdriver → Logging → Registros en la consola de Google Cloud:
Cuando estés en la consola de registros, puedes navegar a Contenedor de GKE para ver todos los registros recopilados de STDOUT:
De forma opcional, puedes exportar los registros a Google BigQuery para realizar un análisis más detallado de los registros o configurar alertas basadas en registros. No podremos hacerlo hoy durante el lab.
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 el 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 tu 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ás toda la configuración de facturación que hayas realizado (primero debes inhabilitar la facturación del proyecto). Además, si borras un proyecto, solo se detendrá toda la facturación después de 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.