Dashboards de Kubernetes 1

Uno de los principales problemas al empezar a trabajar con Kubernetes es la falta de herramientas comprensibles sobre Kubernetes. Los dashboards de kubernetes (las herramientas de gestión de la plataforma) se convierten en el punto de entrada para muchos que quieren aprender Kubernetes.

En esta serie de articulos vamos a examinar algunos de los dashboards más usados, inluyendo algunos más específicos (octant, kontena) y dejando aquellos orientados a PaaS/CaaS (Rancher, Openshift) ya que en ambos casos se sobrepasa el alcance de herramientas de entrada a Kubernetes.

Dashboards de Kubernetes

Kubernetes Dashboard

Con más de 6000 estrellas en GitHUb, el dashboard oficial de Kubernetes es la opción estándar de este tipo de soluciones, a causa de las dependencias del mismo y su falta de compatibilidad con las versiones actuales de Kubernetes nos vamos a centrar en las versión v2-beta3.

Como se instala

Ejecutando el comando:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0-beta3/aio/deploy/recommended.yaml

Se instala en el espacio de nombre “kubernetes-dashboard” y para obtener las métricas utiliza el servicio “dashboard-metrics-scraper” que se instala en el mismo espacio de nombres.

Se debe acceder vía IP external (servicio LoadBalancer o kubectl proxy), o configurar un Ingress con los mismos certificados SSL que la consola (lo que complica su despliegue).

Los contenedores que forman parte de esta solución son:

docker.io/kubernetesui/dashboard                  v2.0.0-beta3        6feddba9df747       32MB
docker.io/kubernetesui/metrics-scraper          v1.0.1               709901356c115       16.1MB

Por lo que su despliegue ha de ser rápido, ya que aunque son dos servicios son de reducido tamaño.

Características

Dispone de un interfaz limpio y claro, autenticación por token y un cuadro de mandos donde a un lado tenemos todos los elementos principales de Kubernetes y en la parte principal del panel una lista de los elementos seleccionados en el nombre de espacios seleccionado.

Panel principal:

Dashboards de Kubernetes 1 1

Por comodidad dispone de un tema oscuro, de los elementos a los que permite acceder tenemos los roles de seguridad.… Read the rest “Dashboards de Kubernetes 1”

Como publicar Kubernetes con External DNS, MetalLB y Traefik.

Kubernetes con External DNS, MetalLB y Traefik nos van a servir para que las aplicaciones web (en un entorno o no de microservicios) se publiquen, ya que los requisitos básicos son resolver por DNS el nombre del equipo y la ruta web que lleva a la aplicación.

El gran mapa

Como publicar Kubernetes con External DNS, MetalLB y Traefik. 17

Tras los pasos realizados en K3s: Kubernetes más simple y Helm v3 para desplegar PowerDNS sobre Kubernetes vamos a darle forma a una solución Kubernetes más completa para que pueda publicar servicios bajo su propio dominio y ruta y que a su vez sea accesible desde el exterior. Y siempre usando los mínimos recursos en esta tarea.

MetalLB

MetalLB que nos permitirá emular la potencia de los balanceadores de los entornos Cloud, los requisitos de está solución son una versión de Kubernetes 1.13 o superior, que no exista otro balanceador de red operativo y que el controlador de red esté soportado en la lista indicada en https://metallb.universe.tf/installation/network-addons/, debemos tener en cuenta que K3s incluye flannel que está soportado y que en el caso de otros como Weave se requieren una serie de modificaciones.

Para instalar MetalLB solo es necesario aplicar el archivo “yaml” que despliega todos los elementos:

$ sudo kubectl apply -f "https://raw.githubusercontent.com/danderson/metallb/master/manifests/metallb.yaml"

Y para activar MetalLB le creamos una configuración (archivo pool.xml) que tendrá la forma:

apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: my-ip-space
      protocol: layer2
      addresses:
      - 192.168.8.240/28

Que al aplicar con k3s kubectl apply -f pool.yml configurará MetalLB para que en el caso de que existan servicios con loadBalancer utilicen una de las IPs definidas en el rango especificado (en este caso 192.168.9.240/28).

MetalLB es una gran ventaja sobre otros tipos de soluciones locales, ya que no requiere del uso de SDN (como es el caso de Kubernetes sobre VMware NSX) o de servidores específicos para la publicación (como el caso de OpenShift, que ademas de SDN requiere de maquinas especificas para publicar servicios).… Read the rest “Como publicar Kubernetes con External DNS, MetalLB y Traefik.”

Helm v3 para desplegar PowerDNS sobre Kubernetes

En el artículo PowerDNS sobre Docker o Podman, fácil y rápido dejamos un punto pendiente sobre Kubernetes, esto es así porque la estructura de servicios de Kubernetes es mucho más compleja que la de Docker o Podman y por tanto hay que hacer un planteamiento completamente diferente.

Helm v3 para desplegar PowerDNS sobre Kubernetes 23

Empaquetar con Helm v3

Lo primero que debemos tener en mente es empaquetar aplicaciones para que su despliegue no requiera de amplios conocimientos sobre Kubernetes (hacer la vida al usuario más fácil) y lo segundo es que podemos tener muchos usuarios sobre el mismo entorno deseando querer la misma aplicación y no podemos crear un paquete para cada uno, debemos poder reutilizar el paquete creado.

En Kubernetes el estándar de paquetes es Helm que nos va a permitir gestionar despliegues de forma fácil y siendo reutilizables por usuario, proyecto, etc. El paquete Helm está formado por:

  • Chart.yaml: Que es la metainformación sobre el propio paquete.
  • templates: Carpeta donde vamos a definir los objetos que van a ser desplegados en Kubernetes, pero que van a tener ciertas modificaciones para que sean flexibles.
  • values.yaml: En los objetos a desplegar existirán una serie de variables que habrán de definirse (p.e. servidores a los que acceder, claves de acceso, bases de datos en un servidor, etc), en este fichero se definen los valores predefinidos de cada variable, para que posteriormente el usuario que lance el paquete pueda ajustarlo a su gusto.
  • NOTES.txt: Dentro de “templates” se coloca este archivo que contendrá un mensaje sobre el resultado de la instalación del paquete, como puede ser como obtener la IP o URL de acceso.
  • _helpers.tpl: Este archivo que también encontraremos dentro de la carpeta “templates” contiene definiciones de variables que podremos usar en las objetos, como es por ejemplo el nombre del paquete correctamente definido y que nos permitirá realizar múltiples despliegues de la misma aplicación en el mismo espacio de nombres simplemente cambiando el nombre de versión del despliegue.
Read the rest “Helm v3 para desplegar PowerDNS sobre Kubernetes”
Abrir publicación
PowerDNS sobre Docker o Podman, fácil y rápido 24

PowerDNS sobre Docker o Podman, fácil y rápido

Que es PowerDNS y DNS como servicio crítico

PowerDNS es un servidor DNS, siendo este un servicio especialmente crítico en cualquier infraestructura que deseemos desplegar, ya que es el principal punto de conexión entre servicios y operadores.

Si de todas las opciones que nos encontramos cuando buscamos un servidor DNS (podemos ver una larga lista en https://en.wikipedia.org/wiki/Comparison_of_DNS_server_software) buscamos las tres siguientes condiciones: que se pueda gestionar fácilmente, despliegue sencillo y OpenSource nos vamos a quedar en una solo opción: PowerDNS y para su gestión PowerDNS-admin.

PowerDNS ( cuyo desarrollo se puede ver en https://github.com/PowerDNS/pdns y tiene más de 1800 estrellas) es un potente servidor DNS cuya características más interesantes para la gestión son disponer de un servicio web con una potente API y ser capaz de almacenar la información en bases de datos, como MySQL.

Y seleccionamos PowerDNS-Admin por dos razones: Está activamente mantenido (https://github.com/ngoduykhanh/PowerDNS-Admin, más de 750 estrellas) y visualmente es un entorno más amigable al tener un formato parecido al que las herramientas de RedHat están usando actualmente.

¿Porqué PowerDNS con PowerDNS-Admin?

Porque conforman un potente paquete donde tenemos las siguientes ventajas:

  • Fácil de instalar
  • Fácil de mantener
  • Interfaz intuitivo
  • Todo está guardado en una base de datos (lo que facilita replicación, copias de seguridad, alta disponibilidad, etc).
  • No requiere configuración especial del navegador (como es el caso de RedHat IDM que requiere instalar el certificado del servidor).
  • Para la gestión de los operadores dispone de autenticación contra múltiples fuentes (LDAP, AD, SAML, Github, Google, etc).
  • Dispone de control sobre los permisos de acceso a los dominios

A estas ventajas hay que unirles la existencia de múltiples contenedores que facilitan sobremanera como desplegar y actualizar está solución.

PowerDNS sobre Docker o Podman, fácil y rápido 25

Desplegar PowerDNS con Docker-Composer

La solución con PowerDNS consta de tres partes: el servidor dns, para el cual haremos uso de contenedor pschiffe/pdns-mysql:alpine (https://github.com/pschiffe/docker-pdns/tree/master/pdnsRead the rest “PowerDNS sobre Docker o Podman, fácil y rápido”

Kubernetes: aventuras y desventuras de parchear (kubectl patch).

Kubernetes es una potente herramienta de orquestación de contenedores donde se ejecutan muchos y diferentes objetos que en algún momento nos va a interesar modificar.

Para ello Kubernetes nos ofrece un interesante mecanismo: patch que vamos a explicar y veremos que está lejos de ser una herramienta lo bastante potente como sería deseable.

Operaciones de parcheo (sustitución) en Kubernetes

Según la documentación de Kubernetes y las normas de la API de Kubernetes se definen tres tipos (con –type):

Strategic

Es el tipo de parche que usa Kubernetes por defecto y es un tipo nativo, definido en el SIG, sigue la estructura del objeto original pero indicando los cambios (por defecto unir: merge, por eso se conoce por strategic merge patch) en un fichero yaml. Por ejemplo si tenemos el siguiente servicio (en el fichero service.yml):

apiVersion: v1
kind: Service
metadata:
  labels:
    app: traefik
  name: traefik
  namespace: kube-system
spec:
  clusterIP: 10.43.122.171
  externalTrafficPolicy: Cluster
  ports:
  - name: http
    nodePort: 30200
    port: 80
    protocol: TCP
    targetPort: http
  - name: https
    nodePort: 31832
    port: 443
    protocol: TCP
    targetPort: https
  selector:
    app: traefik
  type: LoadBalancer

Vamos a utilizar el comando kubectl patch -f service.yml --type="strategic" -p "$(cat patch.yml)" --dry-run -o yaml que nos va a permitir realizar pruebas sobre los objetos sin el peligro de modificar su contenido en el cluster Kubernetes.

Si queremos que dicho servicio escuche por un puerto adicional utilizaremos la estrategia “merge” y aplicaremos el siguiente parche (patch.yml):

spec:
  ports:
  - name: dashboard
    port: 8080
    protocol: TCP
    targetPort: dashboard

Como vemos, el parche solo sigue el objeto servicio hasta donde queremos realizar el cambio (el array “ports”) y al ser un cambio de tipo “strategic merge” se dedicará a añadirlo a la lista como se ve en el volcado del comando:

...
spec:
  clusterIP: 10.43.122.171
  externalTrafficPolicy: Cluster
  ports:
  - name: dashboard
    port: 8080
    protocol: TCP
    targetPort: dashboard
  - name: http
    nodePort: 30200
    port: 80
    protocol: TCP
    targetPort: http
...
Read the rest “Kubernetes: aventuras y desventuras de parchear (kubectl patch).”

Docker: Reducir el tamaño de un contenedor

En entornos de contenedores (Docker o Kubernetes) necesitamos desplegar rápidamente y lo más importante es el tamaño de los mismos. Debemos reducirlos para que la descarga de los mismos desde el registro y su ejecución es más lenta cuanto mayor es el contenedor y eso afecte lo mínimo a la complejidad de las relaciones entre servicios.

Para una demostración de una solución basada en PowerDNS me encuentro que el contenedor original del servicio PowerDNS-Admin ( https://github.com/ngoduykhanh/PowerDNS-Admin/blob/master/docker/Production/Dockerfile)tiene los siguientes detalles:

  • El desarrollador es muy activo e incluye código python, javascript (nodejs) y css. Las imágenes en docker.hub están obsoletas respecto al código.
  • El Dockerfile de producción no genera una imagen válida
  • Está basada en Debian Slim, que aunque elimina gran cantidad de ficheros

En Docker Hub existen imágenes, pero pocas son recientes o no usan el repositorio original por lo que el resultado es de una versión antigua del código. Por ejemplo la imagen más descargada ( really/powerdns-admin) no tiene en cuenta las modificaciones del último año y no usa yarn para la capa nodejs.

Primer paso: Decidir si crear una nueva imagen Docker

A veces es cuestión de la necesidad o del tiempo, en este caso se ha decidido crear una imagen nueva teniendo en cuenta lo indicado anteriormente. Como requisitos mínimos necesitamos una cuenta en GitHub (https://www.github.com), una cuenta en Docker Hub ( https://hub.docker.com/) y conocimientos básicos de git así como avanzados de crear Dockerfile.

En este caso se crea https://github.com/aescanero/docker-powerdns-admin-alpine y https://cloud.docker.com/repository/docker/aescanero/powerdns-admin y se enlazan para poder crear automáticamente las imágenes cuando se suba un Dockerfile a GitHub.

Segundo paso: Elegir la base de un contenedor

Utilizar una base de muy pequeño tamaño y orientada a la reducción de cada uno de los componentes (ejecutables, librerías, etc) que se van a utilizar es el requisito mínimo para reducir el tamaño de un contenedor, y la elección debe ser siempre utilizar Alpine ( https://alpinelinux.org/Read the rest “Docker: Reducir el tamaño de un contenedor”

Navegación de entradas

1 2 3 4
Volver arriba