Ejercicio: Implementación de un contenedor de microservicios en Kubernetes

7 minutos

Kubernetes ejecuta contenedores automáticamente. Describa lo que quiere que haga Kubernetes mediante un archivo YAML. Este ejercicio lo ayudará a crear el archivo para que pueda implementar y ejecutar el servicio back-end en Kubernetes.

Importante

Antes de continuar, debe asegurarse de que tiene instalada una implementación de Kubernetes. Usaremos la implementación k3d que se ejecuta en el espacio de código. Para iniciar el laboratorio, instalaremos esta implementación.

Instalación de herramientas de Kubernetes e implementación

Es necesario instalar tanto la herramienta kubectl como la implementación de Kubernetes k3d:

En el espacio de código, cambie a la pestaña TERMINAL y ejecute estos comandos para instalar los requisitos previos:
```
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
```
A continuación, para descargar la clave de firma para los repositorios de paquetes de Kubernetes, ejecute estos comandos:
```
sudo mkdir /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```
Si recibe un error que indica que el directorio ya existe, ejecute el comando curl por separado.

Agregue el repositorio de Kubernetes a la configuración de apt:

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Ahora puede instalar la herramienta kubectl:

sudo apt-get update
sudo apt-get install -y kubectl

Por último, instale la implementación k3d de Kubernetes y cree un clúster:

curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
k3d cluster create devcluster --config k3d.yml

Creación de un archivo de implementación para el servicio back-end

Puede crear un archivo para administrar la implementación de un contenedor en Kubernetes con un archivo YAML. Vamos a crear un archivo para implementar el servicio back-end.

Cree un nuevo archivo en la carpeta donet-kubernetes del codespace denominado backend-deploy.yml.

Copie el texto siguiente en el archivo y, luego, guárdelo.

---
apiVersion: apps/v1
kind: Deployment
metadata:
    name: productsbackend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: productsbackend
    spec:
      containers:
      - name: productsbackend
        image: [YOUR DOCKER USER NAME]/productservice:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
  selector:
    matchLabels:
      app: productsbackend
---
apiVersion: v1
kind: Service
metadata:
  name: productsbackend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32001
  selector:
    app: productsbackend

Reemplace el marcador de posición [YOUR DOCKER USER NAME] por el nombre de usuario real de Docker.

Este archivo hace un par de cosas.

La primera parte define una especificación de implementación para el contenedor que se implementará en Kubernetes. Especifica una réplica, dónde buscar la imagen de contenedor y qué puertos abrir en el contenedor, y establece algunas variables de entorno. Esta primera parte también define las etiquetas y los nombres con los que se puede hacer referencia al contenedor y a la especificación.

La segunda parte define que el contenedor se ejecuta como un servicio NodePort de Kubernetes. Para este módulo, no es necesario comprender todos los detalles de NodePorts. Sin embargo, debe saber que este tipo de servicio expone una dirección IP externa para poder probar el servicio desde fuera del clúster.

Implementación y ejecución del microservicio de back-end

A continuación, implementaremos y ejecutaremos el microservicio.

En la pestaña TERMINAL, ejecute el comando siguiente:
```
kubectl apply -f backend-deploy.yml
```
Este comando le indica a Kubernetes que ejecute el archivo que acaba de crear. Se descargará la imagen de Docker Hub y se creará el contenedor.
El comando kubectl apply devuelve rápidamente el resultado. Sin embargo, la creación del contenedor puede tardar más tiempo. Para ver el progreso, use el código siguiente.
```
kubectl get pods
```
En la salida resultante, verá una fila con productsbackend seguido de una cadena de caracteres aleatorios en la columna NAME. Cuando todo esté listo, habrá un valor de 1/1 en la columna READY y En ejecución en la columna STATUS.
Para probar el servicio, vuelva a la pestaña PORTS, cerca de la dirección local del puerto de Back-end, seleccione el icono del globo terráqueo. El explorador abre una nueva pestaña en esa dirección.

Para consultar algunos productos, anexe la dirección con /api/product y presione Entrar. Debería ver información del producto indicada en formato JSON.

[
    {
        "id": 1,
        "name": "Solar Powered Flashlight",
        "description": "A fantastic product for outdoor enthusiasts",
        "price": 19.99,
        "imageUrl": "product1.png"
    },
    {
        "id": 2,
        "name": "Hiking Poles",
        "description": "Ideal for camping and hiking trips",
        "price": 24.99,
        "imageUrl": "product2.png"
    },
    {
        "id": 3,
        "name": "Outdoor Rain Jacket",
        "description": "This product will keep you warm and dry in all weathers",
        "price": 49.99,
        "imageUrl": "product3.png"
    },
    ...

Creación de un archivo de implementación y ejecución del servicio front-end

Al igual que el servicio de back-end, también se necesitará un archivo de implementación para el front-end.

Cree un nuevo archivo en la carpeta donet-kubernetes denominada frontend-deploy.yml.

Pegue el código siguiente en el archivo:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: storefrontend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: storefrontend
    spec:
      containers:
      - name: storefrontend
        image: [YOUR DOCKER USER NAME]/storeimage:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
        - name: ProductEndpoint
          value: http://productsbackend
  selector:
    matchLabels:
      app: storefrontend
---
apiVersion: v1
kind: Service
metadata:
  name: storefrontend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32000
  selector:
    app: storefrontend

Reemplace el marcador de posición [YOUR DOCKER USERNAME] por el nombre de usuario real de Docker.

Observará que este archivo es similar al que creamos para el microservicio de back-end. Hay dos diferencias:
- Estamos especificando un contenedor diferente que se ejecute con el valor spec.template.spec.containers.image de la implementación.
- Hay una nueva variable de entorno en la sección spec.template.spec.containers.env. El código de la aplicación storefrontend llama al back-end, pero como no especificamos un nombre de dominio completo (FQDN), ni conocemos la dirección IP del microservicio de back-end, usamos el nombre especificado en el nodo metadata.name de Deployment. Kubernetes se encarga del resto.
Implemente el contenedor en Kubernetes con el comando siguiente:
```
kubectl apply -f frontend-deploy.yml
```
De nuevo, puede usar el comando kubectl get pods para ver el estado de la implementación. Cuando la fila de storefrontend muestre En ejecución en la columna STATUS, estará todo listo.
Para probar el servicio de front-end, cambie a la pestaña PORTS y, a continuación, a la derecha de la dirección local del puerto de front-end, seleccione el icono de globo. El explorador muestra la página de inicio.
Seleccione Productos. El catálogo muestra la mercancía de Contoso.

En este ejercicio, ha creado un archivo de implementación que ha descrito exactamente cómo quería que los contenedores se ejecutaran en Kubernetes. Luego, hizo que Kubernetes descargara la imagen de Docker Hub y que iniciara los contenedores.

Continuar

Ejercicio: Implementación de un contenedor de microservicios en Kubernetes

Instalación de herramientas de Kubernetes e implementación

Creación de un archivo de implementación para el servicio back-end

Implementación y ejecución del microservicio de back-end

Creación de un archivo de implementación y ejecución del servicio front-end

Comentarios