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

7 minutos

Kubernetes ejecuta contenedores por usted. Describe lo que quiere que Kubernetes haga a través de un archivo YAML. Este ejercicio le guía por la creación del archivo para poder 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 e implementación de Kubernetes

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 curl comando 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 una implementación de contenedor de administración de archivos 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 espacio de código denominado backend-deploy.yml.

Copie el texto siguiente en el archivo y 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 que el contenedor se implemente en Kubernetes. Especifica una réplica, donde buscar la imagen de contenedor, qué puertos se van a abrir en el contenedor y establece algunas variables de entorno. Esta primera parte también define etiquetas y nombres que se pueden usar para hacer referencia al contenedor y a la especificación.

A continuació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 back-end

A continuación, vamos a implementar y ejecutar el microservicio.

En la pestaña TERMINAL , ejecute el siguiente comando:
```
kubectl apply -f backend-deploy.yml
```
Este comando indica a Kubernetes que ejecute el archivo que hemos creado. Descarga la imagen de Docker Hub y crea el contenedor.
El kubectl apply comando devuelve rápidamente. Sin embargo, la creación del contenedor puede tardar un tiempo. Para ver el progreso, use el código siguiente.
```
kubectl get pods
```
En la salida resultante, tiene una fila con productsbackend seguida de una cadena de caracteres aleatorios en la columna NAME . Cuando todo esté listo, hay un 1/1 en la columna READY y En ejecución en la columna STATUS .
Para probar el servicio, cambie a la pestaña PUERTOS , cerca de la dirección local del puerto back-end , seleccione el icono de globo. 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 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 de front-end

Al igual que el servicio back-end, también necesitamos 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.

Observe que este archivo es similar al que hemos creado para el microservicio back-end. Hay dos diferencias:
- Estamos especificando un contenedor diferente para que se ejecute en el valor de spec.template.spec.containers.image la implementación.
- Hay una nueva variable de entorno en la spec.template.spec.containers.env sección . El código de la aplicación storefrontend llama al back-end, pero porque no se ha especificado un nombre de dominio completo (FQDN), no conocemos la dirección IP del microservicio back-end, usamos el nombre especificado en el metadata.name nodo 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 kubectl get pods para ver el estado de la implementación. Una vez que la fila de storefrontend se muestra En ejecución en la columna STATUS , todo está listo para usarse.
Para probar el servicio de front-end, cambie a la pestaña PUERTOS y, después, a la derecha de la dirección local del puerto 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, creó un archivo de implementación que describió exactamente cómo quería que los contenedores se ejecutaran en Kubernetes. A continuación, ha descargado la imagen de Kubernetes desde Docker Hub y ha iniciado los contenedores.

Comentarios

¿Le ha resultado útil esta página?