Taller Kubernetes: Despliegues parametrizados

Introducción

En este taller vamos a ver cómo podemos desplegar aplicaciones parametrizadas en Kubernetes. Para ello, vamos a utilizar un ejemplo muy sencillo: una aplicación web que gestione las temperaturas de una localidad y el despliegue y acceso a Nextcloud.

Ejercicio 1: Configurando nuestra aplicación Temperaturas

Recordamos que el componente frontend hace peticiones al componente backend utilizando el nombre temperaturas-backend, que es el nombre que asignamos al Service ClusterIP para el acceso al backend.

Vamos a cambiar la configuración de la aplicación para indicar otro nombre.

Podemos configurar el nombre del servidor backend al que vamos acceder desde el frontend modificando la variable de entorno TEMP_SERVER a la hora de crear el despliegue del frontend.

Por defecto el valor de esa variable es:

TEMP_SERVER temperaturas-backend:5000

Vamos a modificar esta variable en el despliegue del frontend y cambiaremos el nombre del Service del backend para que coincidan, para ello realiza los siguientes pasos:

Vamos a crear el recurso con los siguientes valores:

kubectl create cm temperaturas --from-literal=SERVIDOR_TEMPERATURAS=servidor-temperaturas:5000

Y verificamos que se ha creado correctamente:

kubectl get cm

kubectl describe cm temperaturas

Creamos los ficheros necesarios para el despliegue de la aplicación:

frontend-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: temperaturas-frontend
  labels:
    app: temperaturas
    tier: frontend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: temperaturas
      tier: frontend
  template:
    metadata:
      labels:
        app: temperaturas
        tier: frontend
    spec:
      containers:
      - name: contenedor-temperaturas
        image: iesgn/temperaturas_frontend
        ports:
          - name: http-server
            containerPort: 3000
        env:
          - name: TEMP_SERVER
            valueFrom:
              configMapKeyRef:
                name: temperaturas
                key: SERVIDOR_TEMPERATURAS

frontend-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: temperaturas-frontend
  labels:
    app: temperaturas
    tier: frontend
spec:
  type: NodePort
  ports:
  - port: 3000
    targetPort: http-server
  selector:
    app: temperaturas
    tier: frontend

backend-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: temperaturas-backend
  labels:
    app: temperaturas
    tier: backend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: temperaturas
      tier: backend
  template:
    metadata:
      labels:
        app: temperaturas
        tier: backend
    spec:
      containers:
        - name: contendor-servidor-temperaturas
          image: iesgn/temperaturas_backend
          ports:
            - name: api-server
              containerPort: 5000

backend-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: servidor-temperaturas
  labels:
    app: temperaturas
    tier: backend
spec:
  type: ClusterIP
  ports:
  - port: 5000
    targetPort: api-server
  selector:
    app: temperaturas
    tier: backend

Y realizamos el despliegue de la aplicación:

kubectl apply -f .
kubectl get all

Accedemos a la aplicación y verificamos que funciona correctamente:

Ejercicio 2: Desplegando Nextcloud

Vamos a realizar el despliegue de la aplicación NextCloud + MariaDB. Para ello ten en cuenta lo siguiente:

El despliegue de la base de datos se realizará con una imagen de MariaDB:10.5.
Las variables de entorno que se deben configurar son:
- MYSQL_HOST: nombre del servicio que se creará para la base de datos.
- MYSQL_DATABASE: nombre de la base de datos que se creará.
- MYSQL_USER: nombre del usuario que se creará.
- MYSQL_PASSWORD: contraseña del usuario que se creará.
Deberemos usar un recurso Secret para los datos sensibles y un COnfigMAp para el resto de variables de entorno.

Paso 1: Crear el recurso Secret

Para crear el recurso Secret, ejecuta el siguiente comando:

kubectl create cm bd-datos --from-literal=bd_user=nextcloud \
--from-literal=bd_dbname=nextcloud -o yaml --dry-run=client > bd_datos_configmap.yaml

kubectl create secret generic bd-passwords --from-literal=bd_password=nextcloud \
--from-literal=bd_rootpassword=nextcloud -o yaml --dry-run=client > bd_passwords_secret.yaml

Y los desplegamos:

kubectl apply -f bd_datos_configmap.yaml
kubectl apply -f bd_passwords_secret.yaml

Paso 2: Creamos el fichero de despliegue de la base de datos

Creamos el fichero de despliegue de la base de datos:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mariadb-deployment
  labels:
    app: nextcloud
    type: database
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nextcloud
      type: database
  template:
    metadata:
      labels:
        app: nextcloud
        type: database
    spec:
      containers:
        - name: contenedor-mariadb
          image: mariadb:10.5
          ports:
            - containerPort: 3306
            name: db-port
          env:
            - name: MYSQL_USER
              valueFrom:
                configMapKeyRef:
                  name: bd-datos
                  key: bd_user
            - name: MYSQL_DATABASE
              valueFrom:
                configMapKeyRef:
                  name: bd-datos
                  key: bd_dbname
            - name: MYSQL_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: bd-datos
                  key: bd_password
            - name: MYSQL_ROOT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: bd-datos
                  key: bd_root_password

Paso 3: Creamos el servicio de la base de datos

Creamos el servicio de la base de datos:

apiVersion: v1
kind: Service
metadata:
  name: mariadb-service
  labels:
    app: nextcloud
    type: database
spec:
  selector:
    app: nextcloud
    type: database
  ports:
  - port: 3306
    targetPort: db-port
  type: ClusterIP

Paso 4: Creamos el despliegue de Nextcloud

Creamos el despliegue de Nextcloud:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nextcloud-deployment
  labels:
    app: nextcloud
    type: frontend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nextcloud
      type: frontend
  template:
    metadata:
      labels:
        app: nextcloud
        type: frontend
    spec:
      containers:
        - name: contenedor-nextcloud
          image: nextcloud:latest
          ports:
            - containerPort: 80
              name: http-port
            - containerPort: 443
              name: https-port
          env:
            - name: MYSQL_HOST
              value: mariadb-service
            - name: MYSQL_USER
              valueFrom:
                configMapKeyRef:
                  name: bd-datos
                  key: bd_user
            - name: MYSQL_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: bd-datos
                  key: bd_password
            - name: MYSQL_DATABASE
              valueFrom:
                configMapKeyRef:
                  name: bd-datos
                  key: bd_dbname

Paso 6: Creamos el servicio de Nextcloud

Creamos el servicio de Nextcloud:

apiVersion: v1
kind: Service
metadata:
  name: nextcloud-service
  labels:
    app: nextcloud
    type: frontend
spec:
  selector:
    app: nextcloud
    type: frontend
  ports:
    - name: http-sv-port
      port: 80
      targetPort: http-port
    - name: https-sv-port
      port: 443
      targetPort: https-port
    type: NodePort

Paso 7: Creamos el fichero ingress

Creamos el fichero ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nextcloud-ingress
  labels:
    app: nextcloud
    type: frontend
spec:
  rules:
  - host: www.maria-nextcloud.org
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nextcloud-service
              port:
                number: http-sv-port