Suscripciones ENI: ¡Acceso ilimitado a todos los libros y vídeos de ENI!  Descubrir
Haz tu pedido antes del 21 de diciembre para recibirlo a tiempo antes de Navidad (para entregas en España peninsular)
    1. Libros
    2. Kubernetes - Administre la plataforma de despliegue de sus aplicaciones en contenedores

Kubernetes Administre la plataforma de despliegue de sus aplicaciones en contenedores

  • 5% de descuento en todos los libros, con el código 5DESCUENTO
  • Disponible. Expedido en 24 horas
  • Envío gratis a partir de 25 € de compra
  • Versión online gratis por un año
  • 5% de descuento en todos los libros, con el código 5DESCUENTO
  • Acceso inmediato durante 10 años
  • Versión online digital, no descargable
  • Acceso ilimitado 24/7, durante 10 años
  • Acceso ilimitado 24/7, durante 10 años
  • Todos los libros online de ENI
  • Más de 5 novedades todos los meses
  • Novedades disponibles el mismo día de su publicación
  • Acceso 100% online

Presentación

Este libro está destinado a los administradores de sistemas que deseen dominar el despliegue de Kubernetes y entender cómo responde a los nuevos desafíos de la informática, relacionados con la llegada de los contenedores. De esta manera, el lector va a descubrir las diferentes funcionalidades de Kubernetes, que le permitirán gestionar los contenedores y su ciclo de vida, al mismo tiempo que aprende a configurar todos los componentes esenciales de un clúster en un entorno de producción.

Para comprender de la mejor manera posible este libro, se recomienda tener nociones sobre la administración de un sistema Linux, conocimientos básicos sobre el funcionamiento de las capas de red, el uso de Git, así como conocimientos de un entorno en Cloud. A lo largo del libro, el autor se basa en ejemplos concretos para ayudar al lector a descubrir Kubernetes y asimilar los conceptos que se van adquiriendo.

Después de instalar el entorno y las herramientas imprescindibles para seguir los ejemplos del libro, el autor familiariza al lector con conceptos propios de Kubernetes, como el ciclo de vida de un contenedor, los pods, los servicios o los paneles de control. Poco a poco, el lector va a descubrir conceptos más avanzados, como la persistencia de datos, el alojamiento de aplicaciones en clúster, la configuración de replicaciones entre varios pods, el uso de reglas de alta disponibilidad, la gestión de los componentes internos de Kubernetes o el administrador de paquetes Helm.

Posteriormente, el autor explica cómo instalar y configurar Kubernetes, para ayudar al lector a implementar un clúster en la nube o en máquinas tradicionales, antes de detallar la exposición de una aplicación en Internet, las políticas de red, la seguridad SSL, los balanceos de carga, la elección de máquinas en la nube o incluso la supervisión de aplicaciones. Para terminar, el lector encontrará en los últimos capítulos una introducción al mallado de servicios con Istio, así como información sobre la gestión de permisos de acceso, la noción de operador o la gestión de la aplicación en un sistema de integración continua.

Índice

  • Prólogo
    • 1. Presentación de Kubernetes
      • 1.1 Un poco de historia
      • 1.2 ¿ Qué es un contenedor ?
      • 1.3 Los contenedores antes de Docker
      • 1.4 ¿ Por qué utilizar contenedores ?
      • 1.5 Problemas que surgen con los contenedores
      • 1.6 ¿ Para qué sirve Kubernetes ?
      • 1.7 Recursos externos
    • 2. Unos apuntes sobre la aplicación
      • 2.1 No tiene sentido correr
      • 2.2 Los doce factores de aplicación
      • 2.3 Microservicios vs monolitos
  • Introducción
    • 1. Objetivos del libro
    • 2. Requisitos técnicos previos y recursos documentales
      • 2.1 Requisitos técnicos previos
      • 2.2 Recursos documentales
      • 2.3 Recuperación de los archivos de ejemplo
    • 3. Presentación general
      • 3.1 Requisitos previos
      • 3.2 Utilización de Kubernetes
      • 3.3 Instalación y configuración de Kubernetes
      • 3.4 Extensión del clúster de Kubernetes y nociones avanzadas
      • 3.5 Despliegue e integración continua
      • 3.6 Convenciones utilizadas
  • Instalar el entorno Kubernetes
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Alternativa a la instalación en local
      • 2.1 ¿ Por qué estas alternativas ?
      • 2.2 Utilizar un servicio gestionado
    • 3. Implementar el comando kubectl
      • 3.1 ¿ Para qué sirve kubectl ?
      • 3.2 Instalar kubectl
        • 3.2.1 Instalación en Debian/Ubuntu
        • 3.2.2 Instalación en CentOS/RHEL o Fedora
        • 3.2.3 Instalación con ayuda de Arkade
      • 3.3 Verificar la instalación
      • 3.4 Configurar el autocompletado
        • 3.4.1 Presentación del mecanismo de autocompletado
        • 3.4.2 Archivo de perfil para modificar
        • 3.4.3 Autocompletado en kubectl
        • 3.4.4 Utilizar la variable SHELL
        • 3.4.5 Implementar un alias
    • 4. Implementar Minikube
      • 4.1 ¿ Por qué llamar a Minikube ?
      • 4.2 Descargar e instalar Minikube
      • 4.3 Verificar la instalación de Minikube
      • 4.4 Implementar el autocompletado
    • 5. Instalar el clúster de Kubernetes con Minikube
      • 5.1 Opciones de ejecución
      • 5.2 Instalar Docker
        • 5.2.1 Instalar Docker Community Edition en Ubuntu
        • 5.2.2 Instalación alternativa
        • 5.2.3 Configurar los accesos a Docker
        • 5.2.4 Verificar la instalación de Docker
      • 5.3 Instalar el hipervisor VirtualBox
      • 5.4 Instalar el hipervisor KVM/libvirt
      • 5.5 Configurar el usuario actual
      • 5.6 Desplegar el clúster con Minikube
        • 5.6.1 Crear la máquina Minikube
        • 5.6.2 Arranque/parada de la máquina Minikube
        • 5.6.3 Elegir el contenedor runtime
        • 5.6.4 Extensiones de Minikube
        • 5.6.5 Eliminar la máquina Minikube
    • 6. Algunas nociones sobre el formato YAML
      • 6.1 Declaraciones de pares clave/valor
      • 6.2 Las tablas en YAML
      • 6.3 Las estructuras clave/valor o tabla hash
      • 6.4 Array de tablas hash
  • Panel de control y línea de comandos
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Preámbulo
      • 2.1 Origen del nombre y del logo
      • 2.2 ¿ Por qué utilizar Kubernetes ?
      • 2.3 Origen de Kubernetes
      • 2.4 Fundación CNCF
      • 2.5 Las orquestadores del mercado
    • 3. El panel de control de Kubernetes (dashboard)
      • 3.1 Presentación
      • 3.2 Panel de control Kubernetes en servicio gestionado
      • 3.3 Desplegar el dashboard en Minikube
      • 3.4 Acceder al dashboard en Minikube
      • 3.5 Estructura del panel de control
      • 3.6 Crear un despliegue
        • 3.6.1 Un pequeño apunte sobre MailHog
        • 3.6.2 Ejecutar el despliegue
      • 3.7 Estado de un despliegue
        • 3.7.1 Consultar el estado del despliegue
        • 3.7.2 Consulta del administrador de réplicas
        • 3.7.3 Consulta del estado de un pod
        • 3.7.4 Registro de actividad del contenedor
        • 3.7.5 Escalabilidad
        • 3.7.6 Actualizar la aplicación
        • 3.7.7 Para resumir
    • 4. Presentación de la herramienta kubectl
      • 4.1 Preámbulo
      • 4.2 Consultar elementos
      • 4.3 Lista de pods
      • 4.4 Lista de máquinas de un clúster
        • 4.4.1 Conexión a la máquina Minikube
        • 4.4.2 Lista de nodos de un clúster
        • 4.4.3 Mostrar las características extendidas
    • 5. El motor Containerd de Minikube
      • 5.1 Inicialización del entorno
      • 5.2 Los contenedores asociados a los pods
  • Automatizar y publicar una aplicación
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Gestión por kubectl de una aplicación
      • 2.1 Eliminar un despliegue
      • 2.2 Crear un despliegue
      • 2.3 Estado del despliegue
      • 2.4 Mecanismo de réplicas
        • 2.4.1 Consultar las réplicas
        • 2.4.2 Descripción de las réplicas
      • 2.5 Estado del pod
        • 2.5.1 Lista de pods
        • 2.5.2 Detalles del estado de un pod
      • 2.6 Acceder a los logs de los contenedores
      • 2.7 Acceder a la aplicación MailHog
    • 3. Exposición de servicios
      • 3.1 ¿ Por qué utilizar un servicio ?
      • 3.2 Exponer un despliegue a través de un servicio
      • 3.3 Verificar el servicio mailhog
      • 3.4 ¿ Qué hacer cuando no hay shell ?
        • 3.4.1 Contexto
        • 3.4.2 Utilizar un pod efímero
        • 3.4.3 Lanzamiento de un pod de prueba
      • 3.5 Resiliencia y escalabilidad
        • 3.5.1 Origen de la necesidad
        • 3.5.2 Escalabilidad manual
        • 3.5.3 Número de pods asociados a un despliegue
        • 3.5.4 Detener temporalmente una aplicación
    • 4. Automatización del despliegue usando un archivo YAML
      • 4.1 Mecanismo de creación y actualización
      • 4.2 Estructura YAML de un despliegue
        • 4.2.1 Algunos recordatorios
        • 4.2.2 Recuperación de una estructura con formato YAML
        • 4.2.3 Editar un despliegue
        • 4.2.4 Esqueleto para un despliegue
        • 4.2.5 Crear un despliegue usando un archivo
        • 4.2.6 Eliminar elementos de un archivo
        • 4.2.7 Gestionar la idempotencia y la reentrada
      • 4.3 Crear el servicio
        • 4.3.1 Definición del servicio
        • 4.3.2 Aplicar la definición del servicio
        • 4.3.3 Gestión de la reentrada
      • 4.4 Mecanismo de selector y etiquetas
      • 4.5 Agrupación de la creación de elementos
        • 4.5.1 Creación de un grupo de objetos
        • 4.5.2 Consulta del estado de un grupo de objetos
      • 4.6 Estructura de los objetos
        • 4.6.1 Consultar Kubernetes con kubectl
        • 4.6.2 Referencia de la API en línea
    • 5. Ingress y reverse proxy
      • 5.1 Origen de la necesidad
      • 5.2 Rol de un proxy inverso
      • 5.3 Activación del controlador Ingress en Minikube
      • 5.4 Declarar una regla Ingress
      • 5.5 Consultar las reglas Ingress
      • 5.6 Host virtual y nip.io
        • 5.6.1 Host virtual por defecto
        • 5.6.2 Presentación del mecanismo de nip.io
        • 5.6.3 Configurar el servidor DNS
        • 5.6.4 Crear un host virtual para MailHog
  • Ciclo de vida de un contenedor en Kubernetes
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Gestión de los crashs de la aplicación
      • 2.1 Consultar el estado de los pods
      • 2.2 Conexión al pod
      • 2.3 Contenedor asociado a MailHog
      • 2.4 Comportamiento en caso de crash
      • 2.5 Estado del contenedor después de reiniciar el pod
      • 2.6 Contenedor visto desde Containerd (Minikube)
      • 2.7 Atención a la limpieza
    • 3. Estado de un contenedor
      • 3.1 ¿ Por qué supervisar el estado de un contenedor ?
      • 3.2 Readiness vs Liveness
      • 3.3 Utilización y buena práctica
      • 3.4 Estructura de los campos de supervisión
      • 3.5 Verificar la presencia de un puerto
        • 3.5.1 Definición de la supervisión
        • 3.5.2 Prueba de no disponibilidad sobre un pod no preparado
        • 3.5.3 Estado de los pods en caso de no disponibilidad
        • 3.5.4 Prueba de no disponibilidad sobre un pod en mal estado
        • 3.5.5 Estado de los pods en caso de problema en un pod
        • 3.5.6 Atención a la consistencia de las pruebas
        • 3.5.7 Uniformizar las pruebas
      • 3.6 Supervisión HTTP
        • 3.6.1 ¿ Por qué favorecer este tipo de supervisión ?
        • 3.6.2 Supervisar la aplicación MailHog
      • 3.7 Punto de entrada de supervisión HTTP de una aplicación
        • 3.7.1 Unas observaciones sobre los frameworks modernos
        • 3.7.2 Presentación de la aplicación Flask
        • 3.7.3 Ejemplo de declaración
        • 3.7.4 Desplegar la aplicación Flask
        • 3.7.5 Consultar el estado de la aplicación
      • 3.8 Lanzar un shell
        • 3.8.1 Principio de funcionamiento
        • 3.8.2 Ejemplo de supervisión de una base de datos Postgres
        • 3.8.3 Declaración del comando
    • 4. Definición de la capacidad de un pod
      • 4.1 ¿ Por qué definir una capacidad ?
      • 4.2 Reserva y sobreasignación
      • 4.3 Asignación de recursos a un contenedor
      • 4.4 Asignar recursos a la aplicación MailHog
      • 4.5 Comportamiento en caso de saturación de los recursos
        • 4.5.1 Demanda muy importante de CPU
        • 4.5.2 Desbordamiento de la memoria asignada
      • 4.6 Prioridad de un pod
        • 4.6.1 Presentación del mecanismo
        • 4.6.2 Consultar los tipos por defecto
        • 4.6.3 Consulta de las prioridades de los pods
        • 4.6.4 Crear una clase prioritaria
        • 4.6.5 Asignar una clase prioritaria personalizada
        • 4.6.6 Observación sobre las clases prioritarias por defecto
  • Persistencia de los datos
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Persistencia de los datos
      • 2.1 Origen de la necesidad
      • 2.2 Utilización de un volumen persistente externo
      • 2.3 Volúmenes persistentes
        • 2.3.1 Estructura del volumen persistente
        • 2.3.2 Creación del volumen persistente
      • 2.4 Persistencia de datos con MailHog
        • 2.4.1 Operaciones que se deben realizar
        • 2.4.2 Declarar un objeto PersistentVolumeClaim
        • 2.4.3 Estado de los objetos de volumen persistente
        • 2.4.4 Estado de la petición de volumen persistente
        • 2.4.5 Declaración del punto de montaje
        • 2.4.6 Añadir un punto de montaje al contenedor
        • 2.4.7 Opciones de lanzamiento de MailHog
        • 2.4.8 Declaración completa después de las modificaciones
      • 2.5 Prueba de la persistencia
        • 2.5.1 Instalación de mhsendmail
        • 2.5.2 Abrir la comunicación con el puerto SMTP
        • 2.5.3 Envío de un mensaje electrónico
        • 2.5.4 Permisos del directorio de persistencia de datos
        • 2.5.5 Consultar la interfaz MailHog
        • 2.5.6 Eliminar los pods
        • 2.5.7 Verificar el funcionamiento de la persistencia
    • 3. Clases de almacenamiento
      • 3.1 Origen de la necesidad
      • 3.2 Lista de las clases de almacenamiento
      • 3.3 Detalle de una clase de almacenamiento
      • 3.4 Clase de almacenamiento por defecto
      • 3.5 Las diferentes clases de almacenamiento
        • 3.5.1 Las diferentes familias
        • 3.5.2 Origen de estas familias
      • 3.6 Características de las clases de almacenamiento
        • 3.6.1 Modos de acceso
        • 3.6.2 Características de algunos controladores
        • 3.6.3 Lista de los controladores cargados
      • 3.7 Declaración de una clase de almacenamiento
        • 3.7.1 Estructura de la declaración
        • 3.7.2 Ejemplo de declaración
      • 3.8 Prueba de creación automática de un volumen persistente
  • Alojar una aplicación en clúster
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Desplegar una base de datos MariaDB
      • 2.1 Origen de la necesidad
      • 2.2 Despliegue
        • 2.2.1 Elegir la imagen Docker
        • 2.2.2 Versión inicial del archivo de despliegue
        • 2.2.3 Gestión de la reentrada
      • 2.3 Volumen persistente
        • 2.3.1 Petición de volumen persistente
        • 2.3.2 Estado de la petición de volumen persistente
        • 2.3.3 Añadir una persistencia en el contenedor de MariaDB
        • 2.3.4 Consultar el estado del despliegue
      • 2.4 Configurar la base de datos
      • 2.5 Consultar el estado del pod
        • 2.5.1 Lista de pods
        • 2.5.2 Conexión al contenedor
        • 2.5.3 Crear la entrada de servicio
      • 2.6 Supervisar la base de datos
        • 2.6.1 Definir los comandos de supervisión
        • 2.6.2 Aplicar la modificación
        • 2.6.3 Verificar el despliegue
      • 2.7 Mecanismo de despliegue
    • 3. Implantar un StatefulSet
      • 3.1 Aumentar el número de pods asociados al despliegue
      • 3.2 Presentación del tipo StatefulSet
        • 3.2.1 Características
        • 3.2.2 Limitaciones
      • 3.3 Declaración del primer objeto StatefulSet
        • 3.3.1 Purga del antiguo despliegue
        • 3.3.2 Modificaciones que es preciso realizar
        • 3.3.3 Creación del StatefulSet
        • 3.3.4 Estado de los volúmenes persistentes
        • 3.3.5 Eliminar los antiguos objetos PV/PVC
      • 3.4 Escalabilidad del objeto StatefulSet
      • 3.5 Pods y volúmenes persistentes de un objeto StatefulSet
      • 3.6 Reducir el tamaño del StatefulSet
    • 4. Base y cuenta de pruebas
      • 4.1 Variables de entorno del contenedor
      • 4.2 ConfigMap y Secret
        • 4.2.1 ¿ Por qué llamarlo ?
        • 4.2.2 Estructura de un objeto ConfigMap
        • 4.2.3 Declaración de un objeto Secret
        • 4.2.4 Unión al contenedor
  • Implementar la replicación entre pods
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Sincronizar los pods MariaDB
      • 2.1 Presentación del problema
      • 2.2 Principio de funcionamiento de la sincronización
        • 2.2.1 Operaciones que hay que realizar
        • 2.2.2 Número de réplicas
      • 2.3 Identificadores de los servidores
        • 2.3.1 Conexión a los pods
        • 2.3.2 Conexión a la base de datos
        • 2.3.3 Identificadores de los servidores
        • 2.3.4 ID del maestro
        • 2.3.5 Crear la cuenta de replicación sobre el maestro
        • 2.3.6 Configurar el esclavo
      • 2.4 Activar la sincronización
        • 2.4.1 Activar los registros para la replicación
        • 2.4.2 Comando docker-entrypoint.sh
        • 2.4.3 Consultar el estado del maestro
        • 2.4.4 Configuración del esclavo
      • 2.5 Probar la replicación
        • 2.5.1 Conectar al maestro
        • 2.5.2 Crear una tabla
        • 2.5.3 Conectar al esclavo
    • 3. Automatizar la sincronización
      • 3.1 Scripts de inicio y sincronización
        • 3.1.1 Script de inicio
        • 3.1.2 Configurar la sincronización
        • 3.1.3 Scripts SQL adicionales
        • 3.1.4 Script para detener la base de datos
      • 3.2 Scripts y objeto ConfigMap
      • 3.3 Crear ConfigMap
      • 3.4 Montaje de ConfigMap
        • 3.4.1 Hacer referencia al ConfigMap en la lista de volúmenes
        • 3.4.2 Punto de montaje del ConfigMap
      • 3.5 Arranque y parada del contenedor
        • 3.5.1 Comando de arranque
        • 3.5.2 Comando de parada de la base de datos
      • 3.6 Resumen de las modificaciones
      • 3.7 Estado del despliegue
        • 3.7.1 Estado de los pods
        • 3.7.2 Registro de actividad del pod esclavo
        • 3.7.3 Probar la sincronización
        • 3.7.4 Verificar el funcionamiento de la sincronización
  • Gestionar componentes internos de Kubernetes
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Espacio de nombres kube-system
      • 2.1 Pods presentes en el espacio de nombres kube-system
      • 2.2 CoreDNS
      • 2.3 etcd
      • 2.4 El administrador de red Kindnet
      • 2.5 El administrador de extensiones de Minikube
      • 2.6 El servidor de API
      • 2.7 El proxy Kubernetes (kube-proxy)
      • 2.8 El administrador de tareas (scheduler)
      • 2.9 El administrador de control (controller manager)
      • 2.10 Kubelet
    • 3. Configuración de los servidores maestros
      • 3.1 Principio de lanzamiento de los pods de sistema
      • 3.2 Contenido del directorio /etc/kubernetes/manifests
      • 3.3 Contenido de los archivos
      • 3.4 Desactivar un pod de sistema
      • 3.5 Reactivar el pod de sistema
    • 4. Monitoring de los contenedores del clúster con Glances
      • 4.1 Origen de la necesidad
      • 4.2 Consulta de los DaemonSets
      • 4.3 Presentación de Glances
      • 4.4 Definición de DaemonSet
        • 4.4.1 Estructura de la declaración
        • 4.4.2 Campo volumes
        • 4.4.3 Campo containers
      • 4.5 Creación del DaemonSet
        • 4.5.1 Declaración completa
        • 4.5.2 Creación de DaemonSet
        • 4.5.3 Consulta de los pods
      • 4.6 Anotaciones de tolerancia
        • 4.6.1 Presentación del mecanismo
        • 4.6.2 Recuperación de las anotaciones taints
        • 4.6.3 Tolerancias de ejecución
        • 4.6.4 Modificación de DaemonSet
      • 4.7 Conexión a Glances
  • Helm - Administrador de paquetes
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Presentación de Helm
      • 2.1 ¿ Por qué llamar a Helm ?
      • 2.2 Principio de funcionamiento
    • 3. Despliegue de Helm
      • 3.1 Instalación del cliente Helm
        • 3.1.1 Instalación con el comando Arkade
        • 3.1.2 Instalación manual
      • 3.2 Consultar la versión de Helm
      • 3.3 Configurar el cliente Helm
    • 4. Desplegar una aplicación con Helm
      • 4.1 Determinar el paquete que hay que desplegar
        • 4.1.1 Buscar un chart Helm
        • 4.1.2 Gestionar las fuentes de charts Helm
        • 4.1.3 Buscar y gestionar la caché de Helm
      • 4.2 Instalar el paquete WordPress
        • 4.2.1 Un poco de vocabulario
        • 4.2.2 Lanzamiento de la instalación
        • 4.2.3 Instalación sin acceso directo
      • 4.3 Correcciones de la instalación
        • 4.3.1 Algunas observaciones
        • 4.3.2 Especificar el nombre y el espacio de nombres
        • 4.3.3 Ejecutar la instalación
        • 4.3.4 Actualización y reentrada
        • 4.3.5 Generalizar las opciones de instalación
      • 4.4 Elementos desplegados con Helm
      • 4.5 Eliminar un despliegue
      • 4.6 Anular la eliminación
      • 4.7 Purgar un chart Helm
    • 5. Ciclo de vida de una aplicación desplegada con Helm
      • 5.1 Abrir el puerto hacia WordPress
      • 5.2 Conexión a WordPress
      • 5.3 Configurar un chart Helm
        • 5.3.1 Consultar las opciones de un chart
        • 5.3.2 Configurar la publicación (Minikube)
      • 5.4 Histórico de despliegue
      • 5.5 Visualización de las diferencias antes de la instalación
        • 5.5.1 Origen de la necesidad
        • 5.5.2 Instalar la extensión diff para Helm
        • 5.5.3 Visualizar las modificaciones en el histórico
        • 5.5.4 Visualizar las modificaciones antes de la instalación
      • 5.6 Vuelta atrás
      • 5.7 Portal Artifact Hub
  • Contextos y herramientas de terceros
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Gestión de los contextos con kubectl
      • 2.1 Origen de la necesidad
      • 2.2 Listar los contextos
      • 2.3 Variable de entorno KUBECONFIG
        • 2.3.1 Especificar la ubicación del archivo
        • 2.3.2 Especificar varios archivos
      • 2.4 Cambiar de contexto
      • 2.5 Crear un contexto
      • 2.6 Eliminar un contexto
      • 2.7 Herramientas de gestión de contexto
        • 2.7.1 Presentación de kubectx y kubens
        • 2.7.2 Instalar kubectx y kubens
        • 2.7.3 Implementar el autocompletado
        • 2.7.4 Probar los comandos
      • 2.8 Contexto en el prompt de usuario
        • 2.8.1 ¿ Por qué mostrar el contexto ?
        • 2.8.2 Activación con oh-my-zsh
        • 2.8.3 Activación con bash
        • 2.8.4 Ejemplo de visualización
      • 2.9 Cambiar los colores del terminal con Konsole
        • 2.9.1 Principio de funcionamiento
        • 2.9.2 Creación de la función
        • 2.9.3 Añadir la llamada en la línea de comandos
    • 3. Herramientas de Kubernetes
      • 3.1 k9s: interfaz de texto de seguimiento
        • 3.1.1 Contexto
        • 3.1.2 Instalar k9s
        • 3.1.3 Ejecutar k9s
      • 3.2 Kubespy: trazar la actividad
        • 3.2.1 Presentación de Kubespy
        • 3.2.2 Instalar Kubespy
        • 3.2.3 Observar un despliegue con Kubespy
      • 3.3 Krew: administrador de extensiones
        • 3.3.1 Presentación del mecanismo de extensiones
        • 3.3.2 Instalar Krew
        • 3.3.3 Probar la extensión
      • 3.4 Sniff: capturar el tráfico de red de un pod
        • 3.4.1 Principio de funcionamiento
        • 3.4.2 Instalar Sniff y Wireshark
        • 3.4.3 Ejecutar una secuencia de captura
      • 3.5 Kube Hunter: herramienta de análisis del clúster
        • 3.5.1 Presentación de Kube Hunter
        • 3.5.2 Ejecutar el análisis
        • 3.5.3 Resultado del análisis
        • 3.5.4 Publicar informes en HTML
        • 3.5.5 Ejecución a intervalos regulares
  • Servicios gestionados de Kubernetes
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Servicio gestionado de Google: GKE
      • 2.1 Presentación del servicio de Google
      • 2.2 Administración desde la consola de Google
      • 2.3 Instalar el comando gcloud en local
        • 2.3.1 Instalación en Debian/Ubuntu
        • 2.3.2 Implementar el autocompletado
      • 2.4 Configurar el entorno
        • 2.4.1 Autenticación en Google Cloud
        • 2.4.2 Proyecto asociado con el contexto actual
        • 2.4.3 Activar la API
      • 2.5 Gestión del clúster GKE
        • 2.5.1 Consultar de la lista de clústeres
        • 2.5.2 Versiones y regiones disponibles
      • 2.6 Crear un clúster
        • 2.6.1 Opciones de creación
        • 2.6.2 Ejecutar la creación del clúster
        • 2.6.3 Recuperar el archivo de acceso al clúster
      • 2.7 Consultar el clúster
        • 2.7.1 Lista de nodos
        • 2.7.2 Servicios arrancados
      • 2.8 Delegar los permisos de acceso
        • 2.8.1 Configurar los accesos
        • 2.8.2 Principio del mecanismo subyacente
      • 2.9 Eliminar un clúster GKE
    • 3. Servicio gestionado Microsoft Azure: AKS
      • 3.1 Presentación del servicio Azure
      • 3.2 Administración desde la consola de Azure
        • 3.2.1 Presentación de la consola
        • 3.2.2 Consultar el panel de control de Kubernetes
      • 3.3 Instalación del comando az en local
        • 3.3.1 Instalación en Debian/Ubuntu
        • 3.3.2 Implementar el autocompletado
      • 3.4 Autenticación en el servicio Azure
      • 3.5 Ubicación del despliegue
        • 3.5.1 Lista de ubicaciones
        • 3.5.2 Versiones disponibles de Kubernetes
      • 3.6 Crear un clúster
        • 3.6.1 Crear un grupo de recursos
        • 3.6.2 Ejecutar la creación del clúster
        • 3.6.3 Recuperar el archivo de conexión
        • 3.6.4 Zona DNS por defecto
      • 3.7 Consulta de la lista de clústeres
      • 3.8 Delegar los permisos de acceso
      • 3.9 Eliminar un clúster AKS
    • 4. Servicio gestionado de Amazon: EKS
      • 4.1 Presentación del servicio Amazon AWS
      • 4.2 Introducir el comando eksctl
      • 4.3 Configuración de los accesos Amazon
      • 4.4 Instalar los archivos binarios
        • 4.4.1 Instalar eksctl
        • 4.4.2 Instalar la herramienta aws cli
        • 4.4.3 Verificar la comunicación con AWS
      • 4.5 Crear el clúster EKS
        • 4.5.1 Ayuda en línea de eksctl
        • 4.5.2 Opciones interesantes durante la creación de un clúster
        • 4.5.3 Ejecutar la creación del clúster
      • 4.6 Configurar los accesos kubectl
      • 4.7 Mecanismo de comunicación
      • 4.8 Delegar los permisos de acceso
        • 4.8.1 Configurar los accesos
        • 4.8.2 Principio del mecanismo subyacente
      • 4.9 Eliminar el clúster
    • 5. Servicio Kubernetes OVHcloud
      • 5.1 Presentación de OVHcloud
      • 5.2 Método de creación del clúster y requisitos previos
      • 5.3 Red de los nodos del clúster
      • 5.4 Crear el clúster Kubernetes
      • 5.5 Eliminar el clúster de Kubernetes
    • 6. Acceso en modo lectura-escritura múltiple
      • 6.1 Origen de la necesidad
      • 6.2 Servidor NFS desplegado en Kubernetes
        • 6.2.1 Limitaciones
        • 6.2.2 Desplegar un servidor NFS
        • 6.2.3 Verificar el despliegue
        • 6.2.4 Prueba de creación de volumen persistente (PVC)
      • 6.3 Servicio gestionado de Amazon: EFS
        • 6.3.1 Consultar las instancias de EFS
        • 6.3.2 Crear una instancia de EFS
      • 6.4 Servicio gestionado de Google: Filestore
        • 6.4.1 Consultar las instancias de Filestore
        • 6.4.2 Crear una instancia de Filestore
      • 6.5 Clase de almacenamiento NFS
        • 6.5.1 Instalar el chart
        • 6.5.2 Verificar la instalación del chart
        • 6.5.3 Probar la creación de una petición de volumen persistente (PVC)
      • 6.6 Clase de almacenamiento Azure
  • Instalar Kubernetes en interno
    • 1. Objetivos del capítulo y requisito previos
    • 2. Instalación usando Kubespray
      • 2.1 Origen de la necesidad
      • 2.2 ¿ Por qué Kubespray ?
      • 2.3 Principio de Kubespray
      • 2.4 Requisitos previos de las máquinas que se van a administrar con Ansible
        • 2.4.1 Intercambiar claves SSH
        • 2.4.2 Escalada de permisos sudo
      • 2.5 Estructura del clúster
        • 2.5.1 Arquitectura del clúster Kubespray
        • 2.5.2 Grupos de máquinas
      • 2.6 Preparar los elementos de instalación
        • 2.6.1 Clonar el almacén Git
        • 2.6.2 Instalar los requisitos previos
      • 2.7 Preparar el inventario Ansible
        • 2.7.1 ¿ Qué es un inventario ?
        • 2.7.2 Archivo de inventario de ejemplo
        • 2.7.3 Probar la comunicación Ansible/SSH
      • 2.8 Instalación del clúster
        • 2.8.1 Configuración del clúster
        • 2.8.2 Ejecutar la instalación
        • 2.8.3 Actualización del clúster
      • 2.9 Acceder al clúster
        • 2.9.1 Configurar el acceso al clúster
        • 2.9.2 Utilizar un balanceador de carga
        • 2.9.3 Verificar la comunicación con el clúster
    • 3. Entorno incorporado con k3s
      • 3.1 Presentación y objetivo del proyecto
      • 3.2 Instalación de k3s
      • 3.3 Comunicación con el clúster
      • 3.4 Añadir nodos al clúster
  • Exponer aplicaciones en Internet
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Gestionar las entradas DNS
      • 2.1 Principio de funcionamiento
      • 2.2 Requisitos previos
      • 2.3 Comentarios sobre el funcionamiento del dominio DNS nip.io
      • 2.4 Activar el servicio DNS
        • 2.4.1 Consola Cloud DNS Google
        • 2.4.2 Servicio DNS zonas de Azure
        • 2.4.3 Servicio Route 53 de AWS
      • 2.5 Configurar DNS
        • 2.5.1 Operación que se debe realizar
        • 2.5.2 Consola DNS OVH
        • 2.5.3 Verificar la delegación
      • 2.6 Administrador de DNS
        • 2.6.1 Presentación de la pieza external-dns
        • 2.6.2 Crear la cuenta de administración DNS de Google Cloud
        • 2.6.3 Crear la cuenta de administración DNS service Azure
        • 2.6.4 Crear la cuenta de administración DNS Amazon (Route 53)
        • 2.6.5 Crear un secreto (Google y Azure)
        • 2.6.6 Desplegar external-dns
        • 2.6.7 Verificar el funcionamiento de external-dns
    • 3. Exposición de servicios y balanceo de carga
      • 3.1 Presentación del mecanismo
      • 3.2 Comentarios sobre la noción de servicio
        • 3.2.1 Rol de un servicio
        • 3.2.2 Estructura de un servicio
        • 3.2.3 Tipo ClusterIP
        • 3.2.4 Tipo NodePort y LoadBalancer
        • 3.2.5 Tipo ExternalName
      • 3.3 Servicio asociado al proxy inverso
    • 4. El controlador Ingress
      • 4.1 Principio de funcionamiento
      • 4.2 El rol del controlador Ingress
      • 4.3 Estructura de una regla Ingress
      • 4.4 Permisos necesarios para un controlador
    • 5. El controlador Ingress Google
      • 5.1 Requisitos previos
      • 5.2 Presentación del controlador GLBC
      • 5.3 Despliegue de MailHog
        • 5.3.1 Preparación de la regla Ingress
        • 5.3.2 Desplegar la aplicación MailHog
        • 5.3.3 Consultar el estado del objeto Ingress
        • 5.3.4 Consultar el registro de actividad de external-dns
        • 5.3.5 Consulta de MailHog
    • 6. El controlador Ingress Nginx
      • 6.1 ¿ Por qué cambiar de controlador Ingress ?
      • 6.2 Presentación del software Nginx
      • 6.3 Instalación de Ingress Nginx en GKE (Google)
        • 6.3.1 Determinar el chart Helm que hay que instalar
        • 6.3.2 Espacio de nombres y configuración del chart
      • 6.4 Utilizar el controlador
        • 6.4.1 Utilizar el campo spec.ingressClassName
        • 6.4.2 Verificar el despliegue
      • 6.5 Anotaciones Ingress Nginx
      • 6.6 Ajustar la configuración del controlador Nginx
        • 6.6.1 Recuperar el origen del tráfico
        • 6.6.2 Alta disponibilidad y reglas de afinidad/no-afinidad
        • 6.6.3 Gestionar los controladores Ingress
        • 6.6.4 Reserva y limitación de los recursos disponibles
    • 7. El controlador Ingress Traefik
      • 7.1 Presentación de Traefik
      • 7.2 Instalar el chart Helm
      • 7.3 Utilizar el nuevo controlador Ingress
        • 7.3.1 Seleccionar el controlador Ingress Traefik
        • 7.3.2 Crear la regla Ingress que llama a Traefik
        • 7.3.3 Estado de las reglas Ingress
      • 7.4 Panel de control de Traefik
      • 7.5 Anotaciones Ingress Traefik
      • 7.6 Distribución de la carga y alta disponibilidad
      • 7.7 Reserva y limitación de los recursos disponibles
      • 7.8 Para ir más lejos
  • Securizar el acceso a las aplicaciones
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Implementar Let’s Encrypt
      • 2.1 Presentación de Let’s Encrypt
      • 2.2 Instalar el chart Helm cert-manager
        • 2.2.1 Presentación del chart Helm
        • 2.2.2 Requisitos previos a la instalación
      • 2.3 El emisor de certificados (issuer)
        • 2.3.1 Principio del protocolo ACME
        • 2.3.2 Estructura de la declaración de un emisor
        • 2.3.3 Ejemplo de declaración Issuer Google
        • 2.3.4 Ejemplo de declaración Issuer Azure
        • 2.3.5 Ejemplo de declaración Issuer Amazon
        • 2.3.6 Limitaciones y certificados con joker
      • 2.4 Ejemplos de declaraciones
        • 2.4.1 Servidor Let’s Encrypt de prueba
        • 2.4.2 Servidor Let’s Encrypt de producción
      • 2.5 Declarar los certificados
        • 2.5.1 Estado de los emisores de certificados
        • 2.5.2 Estructura de un certificado
        • 2.5.3 Certificado de prueba
        • 2.5.4 Estado del certificado
        • 2.5.5 Diario de actividad de cert-manager
        • 2.5.6 Consulta del secreto
        • 2.5.7 Certificado de producción
        • 2.5.8 Procedimiento en caso de problemas
      • 2.6 Asociar el certificado a la regla Ingress
      • 2.7 Automatizar la gestión de los certificados
        • 2.7.1 Certificado por defecto del controlador Ingress Nginx
        • 2.7.2 Mecanismo de anotaciones
        • 2.7.3 Emisor de certificados por defecto
    • 3. Protección del acceso a las aplicaciones
      • 3.1 Origen de la necesidad
      • 3.2 Contraseña sencilla (HTTP basic)
        • 3.2.1 Principio de funcionamiento
        • 3.2.2 Crear el secreto con htpasswd
        • 3.2.3 Importar el secreto
        • 3.2.4 Configurar la autenticación
    • 4. Autenticación basada en OAuth2
      • 4.1 Acerca del protocolo OAuth2
      • 4.2 Principio de la solución
      • 4.3 Crear un identificador GitHub
      • 4.4 Desplegar el proxy
        • 4.4.1 Acerca del proxy
        • 4.4.2 Configurar el chart Helm
        • 4.4.3 Desplegar el chart Helm
        • 4.4.4 Estado del despliegue
      • 4.5 Declarar las reglas Ingress
        • 4.5.1 Descripción de las reglas Ingress
        • 4.5.2 Anotaciones Ingress de MailHog
        • 4.5.3 Descripción Ingress del proxy OAuth
        • 4.5.4 Declarar las reglas Ingress
      • 4.6 Prueba de conexión
      • 4.7 Restringir el acceso
        • 4.7.1 Mecanismo de autorización
        • 4.7.2 Restricción por dominio de correo electrónico
        • 4.7.3 Restricción por organización GitHub
  • Network policies
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Las network policies
      • 2.1 Presentación del mecanismo
      • 2.2 Kubernetes Network Plugins
      • 2.3 Network policies en servicios gestionados e instalación propietaria
      • 2.4 Instalación de Calico en Minikube
        • 2.4.1 Activación de CNI en Minikube
        • 2.4.2 Instalar Calico
      • 2.5 Conexiones entrantes
        • 2.5.1 Probar la conexión interna
        • 2.5.2 Bloquear los accesos internos
        • 2.5.3 Probar la regla
      • 2.6 Conexiones salientes
        • 2.6.1 Probar las conexiones externas
        • 2.6.2 Restringir las reglas salientes
        • 2.6.3 Probar la regla
    • 3. Proteger la aplicación WordPress
      • 3.1 Contexto
      • 3.2 Desplegar WordPress
      • 3.3 Restringir los accesos
        • 3.3.1 Referencia del conjunto de flujo
        • 3.3.2 Restringir todos los accesos
        • 3.3.3 Autorizar el acceso del controlador Ingress en WordPress
        • 3.3.4 Autorizar el acceso entre WordPress y MariaDB
        • 3.3.5 Probar las reglas de red
      • 3.4 Recursos externos
  • Escalado automático
    • 1. Objetivos del capítulo y requisitos previos
    • 2. El servidor de métricas
      • 2.1 Presentación del componente metrics-server
      • 2.2 Activar el servidor de métricas
        • 2.2.1 Verificar la presencia del servidor de métricas
        • 2.2.2 Activación en Minikube
        • 2.2.3 Activación en Amazon EKS
      • 2.3 Visualizar el consumo de pods y nodos
        • 2.3.1 Estado de los nodos de un clúster
        • 2.3.2 Estado de los pods
    • 3. Activar el autoscaling
      • 3.1 Prueba con la aplicación MailHog
      • 3.2 Ejecutar un bench
        • 3.2.1 Presentación de Apache Bench
        • 3.2.2 Instalar Apache Bench
        • 3.2.3 Ejecutar la prueba inicial
      • 3.3 Gestionar el escalado
      • 3.4 Ejecución de la prueba
        • 3.4.1 Prueba en frío: escalado de los pods
        • 3.4.2 Prueba en caliente
        • 3.4.3 Reducción del número de pods
    • 4. Escalabilidad de los nodos de un clúster
      • 4.1 Contexto
      • 4.2 Presentación de Autoscaler
      • 4.3 Activar autoscaler con Google Cloud
      • 4.4 Activar autoscaler con Azure AKS
      • 4.5 Activar autoscaler con Amazon EKS
        • 4.5.1 Presentación del mecanismo de ASG
        • 4.5.2 Visualizar los tags de un grupo ASG
        • 4.5.3 Activar autoscaler
        • 4.5.4 Verificar la activación del mecanismo de autoscaler
      • 4.6 Prueba de escalado
        • 4.6.1 Desplegar WordPress
        • 4.6.2 Pods en espera de recursos
        • 4.6.3 Estado de los nodos
        • 4.6.4 Inicio del pod
        • 4.6.5 Limpiar los despliegues
    • 5. Definir grupos de máquinas
      • 5.1 Contexto
      • 5.2 Los diferentes tipos de máquina
        • 5.2.1 Las máquinas preferentes (Spot)
        • 5.2.2 Reservar instancias
        • 5.2.3 Familias de máquinas
        • 5.2.4 Algunos ejemplos de familias de máquinas
        • 5.2.5 Utilizar aceleradores gráficos (GPU)
        • 5.2.6 Algunos ejemplos de coste
      • 5.3 Crear grupos de máquinas
        • 5.3.1 Contexto
        • 5.3.2 Crear un grupo con Google
        • 5.3.3 Crear un grupo con Azure
        • 5.3.4 Crear un grupo con AWS EKS
        • 5.3.5 Crear un grupo con OVH
      • 5.4 Mecanismo de tolerancia y selección de nodos
  • Supervisión con Prometheus
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Implantación de Prometheus
      • 2.1 Acerca de Prometheus
      • 2.2 Funcionamiento de Prometheus
        • 2.2.1 Arquitectura de Prometheus
        • 2.2.2 El motor Prometheus
        • 2.2.3 Los exportadores Prometheus
      • 2.3 Instalar Prometheus
        • 2.3.1 Elegir el chart de Prometheus
        • 2.3.2 ¿ Qué es un operador ?
        • 2.3.3 Desplegar el operador Prometheus
        • 2.3.4 Pods iniciados
        • 2.3.5 Objetos desplegados
        • 2.3.6 Nuevos recursos Prometheus
        • 2.3.7 DaemonSet: node exporter
      • 2.4 Priorizar los componentes de supervisión
        • 2.4.1 El problema de la supervisión
        • 2.4.2 Declaración de las clases de prioridad
        • 2.4.3 Modificar el despliegue de Prometheus
    • 3. Utilizar Prometheus
      • 3.1 Funcionamiento de las métricas
        • 3.1.1 Consultar las métricas de Prometheus
        • 3.1.2 Presentación de la interfaz de Prometheus
        • 3.1.3 Métricas de Kubernetes
        • 3.1.4 Declarar los puntos de recopilación en Kubernetes
        • 3.1.5 Consultar los puntos de recopilación en Prometheus
      • 3.2 Definición de las alertas
        • 3.2.1 Consultar la lista de las alertas
        • 3.2.2 Estructura de una regla de alerta
        • 3.2.3 Definir alertas
      • 3.3 Administrador de alertas
        • 3.3.1 Rol del administrador de alertas
        • 3.3.2 Consultar el administrador de alertas
        • 3.3.3 Configurar las alertas
        • 3.3.4 Desactivar las alertas scheduler y manager (clústeres gestionados)
        • 3.3.5 Configurar el envío de las notificaciones
        • 3.3.6 Dirección de la API de Slack
    • 4. Panel de control de Grafana
      • 4.1 Presentación de Grafana
      • 4.2 Configurar Grafana
        • 4.2.1 Conexión al motor Prometheus
        • 4.2.2 Definición de los paneles de control
      • 4.3 Interfaz de Grafana
      • 4.4 Securización del acceso a Grafana
    • 5. Eliminación del chart de Prometheus
  • Centralizar los registros de actividad
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Principio de la centralización de los registros de actividad
      • 2.1 Arquitectura
      • 2.2 Características del agente desplegado
      • 2.3 Mecanismo de centralización de los logs
    • 3. Centralización en el cloud
      • 3.1 Centralización con ayuda de un servicio gestionado
      • 3.2 Google Stackdriver
        • 3.2.1 Presentación de Stackdriver
        • 3.2.2 Pod Fluentbit (clúster GKE)
        • 3.2.3 Consultar los diarios de actividad
      • 3.3 Azure Monitor
        • 3.3.1 Presentación de Azure Monitor
        • 3.3.2 Consultar los registros de actividad
      • 3.4 Amazon Cloudwatch
        • 3.4.1 Presentación de Cloudwatch
        • 3.4.2 Activar Cloudwatch en el centro de control
        • 3.4.3 Configurar Cloudwatch
        • 3.4.4 Creación de la policy de comunicación con Cloudwatch
        • 3.4.5 Crear una cuenta y adjuntarle la policy
        • 3.4.6 Crear una clave de acceso
        • 3.4.7 Envío de los registros de actividad en Cloudwatch
        • 3.4.8 Estado de los pods desplegados
        • 3.4.9 Consultar los registros de actividad en Cloudwatch
    • 4. Centralizar los diarios de actividad con Loki
      • 4.1 Presentación de Loki
        • 4.1.1 Origen de Loki
        • 4.1.2 Loki vs Elasticsearch
        • 4.1.3 Consejo de utilización
      • 4.2 Instalar Loki
      • 4.3 Configurar la fuente de datos Grafana
      • 4.4 Consultar los registros de actividad en Grafana
        • 4.4.1 Comprobar las fuentes de datos
        • 4.4.2 Consultar los registros de actividad
    • 5. Centralizar los registros de actividad con Elasticsearch
      • 5.1 Advertencias y limitaciones
      • 5.2 Acerca de Elasticsearch
      • 5.3 Desplegar los componentes Elasticsearch
        • 5.3.1 Instalar Elasticsearch
        • 5.3.2 Instalar el agente Filebeat
        • 5.3.3 Instalar Kibana
        • 5.3.4 Instalar Cerebro
      • 5.4 Estado de los diferentes componentes
        • 5.4.1 Estado del motor Elasticsearch
        • 5.4.2 Agente Filebeat
    • 6. Gestionar Elasticsearch
      • 6.1 Acceder a la interfaz Cerebro
      • 6.2 Utilizar Kibana
        • 6.2.1 Acceder a la interfaz de Kibana
        • 6.2.2 Crear un índice
      • 6.3 Conexión a Grafana
        • 6.3.1 Fuente de datos Elasticsearch
        • 6.3.2 Crear un objeto ConfigMap
  • Mallado de servicios con Istio
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Presentación de Istio
      • 2.1 Microservicios y establecimiento de servicios en red
      • 2.2 Presentación de Istio
      • 2.3 Principio de funcionamiento
    • 3. Instarlar Istio
      • 3.1 Configurar external-dns
      • 3.2 Repositorio de los charts Istio
      • 3.3 Instalar istio
      • 3.4 Configurar Istio
        • 3.4.1 Activar los paneles de control
        • 3.4.2 Configurar Istio
      • 3.5 Configurar el componente Gateway Istio
        • 3.5.1 Presentación del mecanismo
        • 3.5.2 Instalar el componente Gateway
        • 3.5.3 Generar el certificado
    • 4. Utilización de Istio
      • 4.1 Inyectar pods en el mallado de servicios
        • 4.1.1 Instalar istioctl
        • 4.1.2 Inyectar el sidecar con istioctl
        • 4.1.3 Inyectar el sidecar por anotación
        • 4.1.4 Desactivar el sidecar por anotación
      • 4.2 Desplegar una aplicación de prueba
        • 4.2.1 Principio de la exposición de aplicación con Istio
        • 4.2.2 Preparar el archivo de despliegue MailHog
        • 4.2.3 Declarar el servicio MailHog
        • 4.2.4 Crear el objeto Gateway
        • 4.2.5 Crear el servicio virtual (VirtualService)
      • 4.3 Securizar los flujos
        • 4.3.1 Activar Mutual TLS (mTLS)
        • 4.3.2 Consultar las policies del servicio MailHog
        • 4.3.3 Forzar el uso de mTLS
    • 5. Panel de control
      • 5.1 Presentación de los diferentes componentes
      • 5.2 Interfaz Kiali
      • 5.3 Interfaz de Grafana
      • 5.4 Interfaz Jaeger
  • Compilar y almacenar imágenes de Docker
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Crear una imagen de Docker
      • 2.1 Aplicar un ejemplo Flask HealthCheck
        • 2.1.1 Presentación de la aplicación
        • 2.1.2 Presentación de las dependencias
        • 2.1.3 Describir las dependencias
        • 2.1.4 Instalar las dependencias
        • 2.1.5 Inicializar la aplicación
        • 2.1.6 Función raíz
        • 2.1.7 Ejecutar el programa
      • 2.2 Entorno de compilación
      • 2.3 El archivo Dockerfile
        • 2.3.1 Presentar el formato
        • 2.3.2 Crear la imagen
        • 2.3.3 Compilar y etiquetar la imagen
        • 2.3.4 Autenticación en el registro de imágenes de Docker
        • 2.3.5 Enviar la imagen al registro
    • 3. Imagen de Docker multietapa (multistage)
      • 3.1 Origen de la necesidad
      • 3.2 Ejemplo de compilación con Maven
    • 4. Análisis de imágenes
      • 4.1 Histórico de los comandos
      • 4.2 Análisis de la imagen: Dive
        • 4.2.1 Presentación de Dive
        • 4.2.2 Instalar Dive
        • 4.2.3 Consultar el contenido de una imagen
    • 5. Utilizar registros de Docker privados
      • 5.1 Origen de la necesidad
      • 5.2 Desplegar la imagen de un registro privado
        • 5.2.1 Exposición del problema
        • 5.2.2 Crear el secreto
        • 5.2.3 Utilizar el secreto
        • 5.2.4 Utilizar una cuenta de servicio
        • 5.2.5 Copiar un secreto entre espacios de nombres
      • 5.3 Errores de recuperación de las imágenes
        • 5.3.1 Detectar los errores
        • 5.3.2 Error sobre el nombre de la imagen
        • 5.3.3 Secreto ausente o no especificado
        • 5.3.4 Identificador inválido
      • 5.4 Servicios de registros gestionados
        • 5.4.1 Soluciones gestionadas
        • 5.4.2 Servicio Google Container Registry
        • 5.4.3 GitLab.com
  • Factoría de software
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Compilación mediante GitLab
      • 2.1 Aplicación para compilar
      • 2.2 Mecanismo de pipeline GitLab
      • 2.3 Dirección y contenido del repositorio
      • 2.4 Estructura del archivo .gitlab-ci.yml
      • 2.5 Ejemplo de archivo .gitlab-ci.yml de compilación de imagen
      • 2.6 Construir la imagen con Kaniko
      • 2.7 En lo sucesivo
    • 3. Despliegue continuo con Jenkins
      • 3.1 Acerca de Jenkins
      • 3.2 Instalar Jenkins
        • 3.2.1 Configurar el chart
        • 3.2.2 Verificar la instalación
        • 3.2.3 Conexión a la interfaz de Jenkins
        • 3.2.4 Instalación de extensiones
    • 4. Pipeline de despliegue continuo con Jenkins
      • 4.1 Requisitos previos
      • 4.2 Presentación del mecanismo de despliegue continuo
      • 4.3 Almacenar los identificadores Docker
      • 4.4 Crear el entorno desarrollo
      • 4.5 Crear el pipeline
        • 4.5.1 Crear el pod de compilación
        • 4.5.2 Esqueleto del pipeline de despliegue
        • 4.5.3 Recuperar el código fuente
        • 4.5.4 Comprobaciones y pruebas
        • 4.5.5 Compilación de la imagen de Docker
        • 4.5.6 Conexión al registro y publicación
        • 4.5.7 Actualización del despliegue de prueba
        • 4.5.8 Programa completo
      • 4.6 Ejecutar la compilación
        • 4.6.1 Crear el job
        • 4.6.2 Ejecutar la build
      • 4.7 Cuenta de servicio
        • 4.7.1 Operaciones que hay que realizar
        • 4.7.2 Crear una cuenta de servicio
        • 4.7.3 Crear el rol de actualización
        • 4.7.4 Asignar el rol a la cuenta de servicio
        • 4.7.5 Asignar la cuenta de servicio
        • 4.7.6 Volver a ejecutar la compilación
      • 4.8 Utilizar Kaniko con Jenkins
      • 4.9 Mecanismo de Webhook
        • 4.9.1 Presentación del mecanismo
        • 4.9.2 Desencadenar el Webhook
        • 4.9.3 Crear el Webhook
    • 5. Algunas palabras sobre Jenkins X
  • Empaquetar su aplicación con Helm
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Helm
      • 2.1 Origen de la necesidad
      • 2.2 Crear un chart
      • 2.3 Contenido de un paquete
        • 2.3.1 Estructura de un paquete
        • 2.3.2 Variables .Values, .Chart y .Release
      • 2.4 Adaptación a la aplicación MailHog
        • 2.4.1 Resumen de los trabajos por realizar
        • 2.4.2 Utilizar la imagen de MailHog
        • 2.4.3 Corrección sobre los puertos de servicio
        • 2.4.4 Añadir un ConfigMap
        • 2.4.5 Añadir el volumen persistente
        • 2.4.6 Montaje del volumen en el contenedor
        • 2.4.7 Prueba de desarrollo
      • 2.5 Dependencias
        • 2.5.1 Declaración de las dependencias
        • 2.5.2 Recuperar las dependencias
        • 2.5.3 Desplegar el chart con las dependencias
    • 3. Template Go
      • 3.1 Principio de funcionamiento
      • 3.2 Sustituir el contenido de una variable
      • 3.3 Bloques condicionales
      • 3.4 Gestión de las condiciones
        • 3.4.1 Los valores verdadero o falso
        • 3.4.2 Operadores de comparación
        • 3.4.3 Condiciones múltiples y negación
      • 3.5 Iteración
        • 3.5.1 Visualización del contenido de una tabla
        • 3.5.2 Eliminar los saltos de línea supernumerarios
        • 3.5.3 Iterar en un grupo fijo de elementos
        • 3.5.4 Iteración sobre una tabla hash
        • 3.5.5 Acceder a una variable global desde un bucle
      • 3.6 Filtros
      • 3.7 Valores por defecto
      • 3.8 Función template
        • 3.8.1 Ejemplo de definición de función
        • 3.8.2 Pasar argumentos y contexto global
      • 3.9 Volver a desplegar por cambio de la configuración
        • 3.9.1 Exposición del problema
        • 3.9.2 Principio de la solución
        • 3.9.3 Ejemplo de implementación
      • 3.10 Generación de secreto aleatorio «estable»
        • 3.10.1 Exposición del problema
        • 3.10.2 Principio de la solución e implementación
  • Restringir y delegar el acceso
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Configurar cuotas
      • 2.1 Origen de la necesidad
      • 2.2 Cuotas por defecto en un espacio de nombres
        • 2.2.1 Crear un espacio de nombres
        • 2.2.2 Estructura de un objeto LimitRange
        • 2.2.3 Ejemplo de definición de limitaciones
        • 2.2.4 Verificar la aplicación de las limitaciones
        • 2.2.5 Probar el mecanismo
        • 2.2.6 Análisis del problema
      • 2.3 Cuotas globales en un espacio de nombres
        • 2.3.1 Presentación de las cuotas de recursos (ResourceQuota)
        • 2.3.2 Estructura de una cuota de recursos
        • 2.3.3 Ejemplos de restricción de consumo de CPU y memoria
        • 2.3.4 Campos para posicionar las limitaciones (campo hard)
        • 2.3.5 Probar el mecanismo
        • 2.3.6 Limpieza al final del ejercicio
    • 3. Autenticación y autorización
      • 3.1 Origen de la necesidad
      • 3.2 Requisitos previos
      • 3.3 Activar los accesos anónimos
        • 3.3.1 Activar los accesos anónimos en Minikube
        • 3.3.2 Crear el archivo de acceso
        • 3.3.3 Asignar los permisos de lectura
        • 3.3.4 Eliminar los permisos de acceso anónimos
      • 3.4 Principio de autenticación por certificado
      • 3.5 Problema de la revocación de certificados
      • 3.6 Generar el certificado
        • 3.6.1 Crear la clave y el certificado cliente
        • 3.6.2 Ubicación de la PKI
        • 3.6.3 Firma del certificado
      • 3.7 Autenticación por certificado
        • 3.7.1 Recuperar la información de conexión al clúster
        • 3.7.2 Usar el certificado para la autenticación
        • 3.7.3 Probar la conexión
      • 3.8 Algunos ejemplos de error de manipulación
        • 3.8.1 Problema de autoridad de certificación
        • 3.8.2 Problema de pareja clave/certificado
        • 3.8.3 No hay identificador
        • 3.8.4 Utilizar la petición de certificado en lugar del certificado
      • 3.9 Asignar permisos administrativos sobre el clúster
        • 3.9.1 Contexto y operaciones que hay que realizar
        • 3.9.2 Asignar permisos administrativos a un usuario
        • 3.9.3 Prueba del nuevo administrador
        • 3.9.4 Crear nuevos usuarios
        • 3.9.5 Asignar permisos de administrador a un grupo
        • 3.9.6 Administrador de un espacio de nombres
    • 4. Mecanismos de autenticación externos
      • 4.1 Presentación del mecanismo
      • 4.2 Comunicación entre el proveedor OAuth2 y el clúster
      • 4.3 Crear los identificadores
      • 4.4 Modificar las opciones de inicio (Minikube)
      • 4.5 Configurar los accesos cliente
        • 4.5.1 Presentación de la herramienta k8s-oidc-helper
        • 4.5.2 Instalar el compilador Go
        • 4.5.3 Instalar k8s-oidc-helper
        • 4.5.4 Generar los identificadores de acceso
        • 4.5.5 Información del clúster y contexto
        • 4.5.6 Probar la conexión
      • 4.6 Asignar permisos de acceso
    • 5. Implantar cuentas de servicio
      • 5.1 Contexto
      • 5.2 Crear la cuenta de servicio
      • 5.3 Asignación de los permisos de administrador de la cuenta de servicio
      • 5.4 Crear el archivo Kubeconfig
        • 5.4.1 Volver a copiar la información de conexión
        • 5.4.2 Token de conexión de la cuenta de servicio
        • 5.4.3 Asignación del usuario
        • 5.4.4 Probar la conexión
        • 5.4.5 Revocar el acceso
  • Los operadores de Kubernetes
    • 1. Objetivos del capítulo y requisitos previos
    • 2. Utilizar los operadores
      • 2.1 Presentación del principio
      • 2.2 El operador de Prometheus
        • 2.2.1 Resultado del chart prometheus-operator
        • 2.2.2 Estructura de un objeto Prometheus
      • 2.3 Recursos externos sobre los operadores existentes
      • 2.4 Presentación del operador MySQL
        • 2.4.1 Justificación de la elección de MySQL
        • 2.4.2 Elección del operador
      • 2.5 Desplegar el operador
      • 2.6 Crear una instancia MysqlCluster
        • 2.6.1 Crear un secreto para la instancia MysqlCluster
        • 2.6.2 Crear el clúster
        • 2.6.3 Problemas de permisos sobre el volumen persistente
      • 2.7 Objetos creados durante el despliegue del clúster
        • 2.7.1 Volúmenes persistentes
        • 2.7.2 Servicios MySQL
      • 2.8 Panel de control del operador
      • 2.9 Prueba de replicación
        • 2.9.1 Conexión a las instancias maestra y esclava
        • 2.9.2 Crear una tabla
        • 2.9.3 Alimentar la tabla
        • 2.9.4 Cambiar el número de réplicas
      • 2.10 Para terminar
  • Anexos
    • 1. bash vs zsh
      • 1.1 Los shells Unix
      • 1.2 zsh y oh-my-zsh
      • 1.3 Probar zsh y oh-my-zsh
      • 1.4 Configurar zsh como shell para el usuario actual
    • 2. Desplegar el panel de control de Kubernetes
      • 2.1 Instalar el panel de control (application dashboard)
      • 2.2 Crear la cuenta de acceso
      • 2.3 Recuperar el token de conexión
      • 2.4 Decodificar el contenido del token
      • 2.5 Conexión al panel de control
      • índice

Autor

Yannig PERRÉMás información

Yannig PERRÉ ha sido administrador de sistemas durante muchos años. Ahora es especialista en la gestión de aplicaciones desarrolladas en microservicios, utilizando contenedores. De manera natural, combina este conocimiento con diferentes herramientas para gestionar los problemas de instalación, resiliencia, escalabilidad y publicación de aplicaciones en Internet. Esta experiencia, combinada con su larga experiencia en el mundo open source, le permite ofrecer a los lectores libros realmente efectivos sobre la implementación de Kubernetes o Ansible.

Características

  • Nivel Medio a Experto
  • Número de páginas 854 páginas
  • Publicación enero 2023
    • Encuadernación rústica - 17 x 21 cm
    • ISBN: 978-2-409-03942-3
    • EAN: 9782409039423
    • Ref. ENI: EIT2KUB
  • Nivel Experto a Medio
  • Publicación enero 2023
    • HTML
    • ISBN: 978-2-409-03943-0
    • EAN: 9782409039430
    • Ref. ENI: LNEIT2KUB

Descargas

  • EIT2KUB.zip