Cómo configurar un flujo de entrega continua con Flux en Kubernetes de DigitalOcean

El autor seleccionó el Fondo de Código Libre y Abierto para recibir una donación como parte del programa Write for DOnations .

Introducción

Por sí solo, Kubernetes no ofrece funciones de integración e implementación continuas. Si bien estos conceptos no suelen estar muy extendidos en proyectos más pequeños, a los equipos más grandes que alojan y actualizan sus implementaciones de forma extensiva les resulta mucho más fácil configurar dichos procesos para aliviar las tareas manuales que consumen mucho tiempo y, en cambio, centrarse en el desarrollo del software que se está implementando. Un enfoque para mantener la entrega continua para Kubernetes es GitOps .

GitOps ve los repositorios de Git que alojan la aplicación y los manifiestos de Kubernetes como la fuente central de verdad con respecto a las implementaciones. Permite entornos de implementación separados mediante el uso de ramas de repositorio, le brinda la capacidad de reproducir rápidamente cualquier estado de configuración, actual o anterior, en cualquier clúster y hace que las reversiones sean triviales gracias al control de versiones de Git. Los manifiestos son seguros, sincronizados y fácilmente accesibles en todo momento. Las modificaciones al manifiesto o la aplicación se pueden auditar, permitir o denegar según factores externos (generalmente, el sistema de integración continua). Automatizar el proceso desde la inserción del código hasta su implementación en un clúster puede aumentar en gran medida la productividad y mejorar la experiencia del desarrollador, al tiempo que hace que la implementación sea siempre coherente con la base de código central.

Flux es una herramienta de código abierto que facilita el enfoque de entrega continua de GitOps para Kubernetes. Flux permite implementaciones automatizadas de aplicaciones y configuraciones en sus clústeres al monitorear los repositorios de Git configurados y aplicar automáticamente los cambios tan pronto como estén disponibles. Puede aplicar manifiestos de Kustomize (que brindan una manera fácil de aplicar parches opcionales a partes de los manifiestos habituales de Kubernetes sobre la marcha), así como supervisar los lanzamientos de gráficos de Helm. También puede configurarlo para recibir notificaciones a través de Slack, Discord, Microsoft Teams o cualquier otro servicio que admita webhooks. Los webhooks brindan una forma de notificar a una aplicación o un servicio sobre un evento que sucedió en otro lugar y proporcionar su descripción.

En este tutorial, instalarás Flux y lo usarás para configurar la entrega continua de la aplicación podinfo en tu clúster Kubernetes de DigitalOcean . podinfoes una aplicación que proporciona detalles sobre el entorno en el que se ejecuta. Alojarás los repositorios que contienen la configuración de Flux podinfoen tu cuenta de GitHub . Configurarás Flux para que supervise el repositorio de la aplicación, aplique automáticamente los cambios y te notifique en Slack mediante webhooks. Al final, todos los cambios que realices en el repositorio monitoreado se propagarán rápidamente a tu clúster.

Prerrequisitos

Para completar este tutorial, necesitarás:

• Un clúster Kubernetes de DigitalOcean con su configuración de conexión configurada como kubectlpredeterminada. Las instrucciones sobre cómo realizar la configuración kubectlse muestran en el paso Conectarse a su clúster cuando crea su clúster. Para obtener información sobre cómo crear un clúster Kubernetes en DigitalOcean, consulte Inicio rápido de Kubernetes .

• Un espacio de trabajo de Slack del que eres miembro. Para saber cómo crear un espacio de trabajo, visita la [documentación oficial] ( https://slack.com/help/articles/206845317-Create-a-Slack-workspace ).

• Una cuenta de GitHub con un token de acceso personal (PAT) creado con todos los privilegios. Para saber cómo crear uno, visita la documentación oficial .

• Git se ha inicializado y configurado en su máquina local. Para comenzar a usar Git y ver las instrucciones de instalación, visite el tutorial Cómo contribuir al código abierto: Introducción a Git .

• El repositorio de la aplicación podinfo se bifurcó en tu cuenta de GitHub. Para obtener instrucciones sobre cómo bifurcar un repositorio en tu cuenta, visita la documentación oficial de introducción .

Paso 1: Instalación y arranque de Flux

En este paso, configurará Flux en su máquina local, lo instalará en su clúster y configurará un repositorio Git dedicado para almacenar y versionar su configuración.

En Linux, puedes usar el script oficial de Bash para instalar Flux. Si estás en MacOS, puedes usar el script oficial, siguiendo los mismos pasos que para Linux, o usar Homebrew para instalar Flux con el siguiente comando:

brew install fluxcd/tap/flux

Para instalar Flux utilizando el script provisto oficialmente, descárguelo ejecutando el siguiente comando:

curl https://fluxcd.io/install.sh -so flux-install.sh

Puede inspeccionar el flux-install.shscript para verificar que sea seguro ejecutando este comando:

less ./flux-install.sh

Para poder ejecutarlo debes marcarlo como ejecutable:

chmod +x flux-install.sh

Luego, ejecute el script para instalar Flux:

./flux-install.sh

Verá el siguiente resultado, que detalla qué versión se está instalando:

Output[INFO]  Downloading metadata https://api.github.com/repos/fluxcd/flux2/releases/latest[INFO]  Using 0.13.4 as release[INFO]  Downloading hash https://github.com/fluxcd/flux2/releases/download/v0.13.4/flux_0.13.4_checksums.txt[INFO]  Downloading binary https://github.com/fluxcd/flux2/releases/download/v0.13.4/flux_0.13.4_linux_amd64.tar.gz[INFO]  Verifying binary download[INFO]  Installing flux to /usr/local/bin/flux

Para habilitar el autocompletado de comandos, ejecute el siguiente comando para configurar el shell:

echo ". (flux completion bash)"  ~/.bashrc

Para que los cambios surtan efecto, vuelva a cargar ~/.bashrcejecutando:

. ~/.bashrc

Ahora tienes Flux disponible en tu máquina local. Antes de instalarlo en tu clúster, primero deberás ejecutar las comprobaciones de requisitos previos que verifican la compatibilidad:

flux check --pre

Flux se conectará a tu clúster, al que hayas configurado una conexión en los requisitos previos. Verás un resultado similar a este:

Output► checking prerequisites✔ kubectl 1.21.1 =1.18.0-0✔ Kubernetes 1.20.2 =1.16.0-0✔ prerequisites checks passed

Nota: Si ve un error o una advertencia, vuelva a verificar el clúster al que está conectado. Es posible que deba realizar una actualización para poder usar Flux. Si kubectlse informa que falta, repita los pasos de los requisitos previos para su plataforma y verifique que esté en su PATH.

Durante el proceso de arranque, Flux crea un repositorio Git en un proveedor específico y lo inicializa con una configuración predeterminada. Para ello, se requiere el nombre de usuario de GitHub y el token de acceso personal, que se obtuvieron en los requisitos previos. El repositorio estará disponible en su cuenta de GitHub.

Almacenarás tu nombre de usuario de GitHub y tu token de acceso personal como variables de entorno para evitar tener que escribirlos varias veces. Ejecuta los siguientes comandos y reemplaza las partes resaltadas con tus credenciales de GitHub:

export GITHUB_USER=your_username
export GITHUB_TOKEN=your_personal_access_token

Ahora puedes arrancar Flux e instalarlo en tu clúster ejecutando:

flux bootstrap github 
  --owner=$GITHUB_USER 
  --repository=flux-config 
  --branch=main 
  --path=./clusters/my-cluster 
  --personal

En este comando, especifica que el repositorio debe llamarse flux-configen el proveedor github, que es propiedad del usuario que acaba de definir. El nuevo repositorio será personal (no estará bajo una organización) y se convertirá en privado de manera predeterminada.

El resultado que verás será similar a esto:

Output► connecting to github.com► cloning branch "main" from Git repository "https://github.com/GITHUB_USER/flux-config.git"✔ cloned repository► generating component manifests✔ generated component manifests✔ committed sync manifests to "main" ("b750ffae686c2f110364694d2ddae26c7f18c6a2")► pushing component manifests to "https://github.com/GITHUB_USER/flux-config.git"► installing components in "flux-system" namespace✔ installed components✔ reconciled components► determining if source secret "flux-system/flux-system" exists► generating source secret✔ public key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDKw943TnUiKLVk4WMLC5YCeC+tIPVvJprQxTfLqcwkHtedMJPanJFifmbQ/M3CAq1IgqyQTydRJSJu6E/4YDOwx1vawStR9XU16rkn+rZbmvRxZ97E0HNb5m54OwmziAWf0EPdsfiIIJYSRkCMihpKJUNoakl+sng6LQsW+WIRlOK39aJRWud+rygQEuEKmD7YHKQ0VSb/L5v50jiPgEZImiREHNfjBU+RkEni3aZuOO3jNy5WdlPkpdqfHe8fdFsjJnvNB0zmfe3eTIB2fbdDzxo2usLbFeAMhGCRYsGnniHsytBHNLmxDM/4I18xlNN9e6WEYpgHEJVb8azKmwSX✔ configured deploy key "flux-system-main-flux-system-./clusters/my-cluster" for "https://github.com/GITHUB_USER/flux-config"► applying source secret "flux-system/flux-system"✔ reconciled source secret► generating sync manifests✔ generated sync manifests✔ committed sync manifests to "main" ("1dc033e24f3288a70ff80c57816e16c52bc62303")► pushing sync manifests to "https://github.com/GITHUB_USER/flux-config.git"► applying sync manifests✔ reconciled sync configuration◎ waiting for Kustomization "flux-system/flux-system" to be reconciled✔ Kustomization reconciled successfully► confirming components are healthy✔ source-controller: deployment ready✔ kustomize-controller: deployment ready✔ helm-controller: deployment ready✔ notification-controller: deployment ready✔ all components are healthy

Flux notó que creó un nuevo Git repository, le asignó una configuración inicial básica y aprovisionó los controladores necesarios en su clúster.

En este paso, instalaste Flux en tu máquina local, creaste una nueva Git repositorypara almacenar su configuración e implementaste sus componentes del lado del servidor en tu clúster. Los cambios definidos por las confirmaciones en el repositorio ahora se propagarán a tu clúster automáticamente. En el siguiente paso, crearás manifiestos de configuración para ordenar a Flux que automatice las implementaciones de la podinfoaplicación que bifurcaste cada vez que se produzca un cambio.

Paso 2: Configuración de la implementación automatizada

En esta sección, configurará Flux para supervisar el podinforepositorio que ha bifurcado y aplicar los cambios a su clúster tan pronto como estén disponibles.

Además de crear el repositorio y la configuración inicial, Flux ofrece comandos para ayudarte a generar manifiestos de configuración con tus parámetros más rápido que si los escribieras desde cero. Los manifiestos, independientemente de lo que definan, deben estar disponibles en su repositorio Git para que se tengan en cuenta. Para agregarlos al repositorio, primero tendrás que clonarlo en tu máquina para poder enviar cambios. Hazlo ejecutando el siguiente comando:

git clone https://github.com/$GITHUB_USER/flux-config ~/flux-config

Es posible que se le solicite su nombre de usuario y contraseña. Ingrese el nombre de usuario de su cuenta y proporcione su token de acceso personal para la contraseña.

Luego, navega hasta él:

cd ~/flux-config

Para indicarle a Flux que monitoree el podinforepositorio bifurcado, primero deberá indicarle dónde se encuentra. Esto se logra creando un manifiesto de GitRepository , que detalla la URL del repositorio, la rama y el intervalo de monitoreo.

Para crear el manifiesto, ejecute el siguiente comando:

flux create source git podinfo 
  --url=https://github.com/$GITHUB_USER/podinfo 
  --branch=master 
  --interval=30s 
  --export  ./clusters/my-cluster/podinfo-source.yaml

Aquí, especifica que la fuente será una Git repositorycon la URL y la rama indicadas. Pasa --exporta output el manifiesto generado y lo envía a podinfo-source.yaml, ubicado en ./clusters/my-cluster/el repositorio de configuración principal, donde se almacenan los manifiestos del clúster actual.

Puede mostrar el contenido del archivo generado ejecutando:

cat ./clusters/my-cluster/podinfo-source.yaml

El resultado será similar a esto:

~/flux-config/clusters/mi-clúster/podinfo-source.yaml

---apiVersion: source.toolkit.fluxcd.io/v1beta1kind: GitRepositorymetadata:  name: podinfo  namespace: flux-systemspec:  interval: 30s  ref:    branch: master  url: https://github.com/GITHUB_USER/podinfo

Puede verificar que los parámetros que acaba de pasar a Flux estén correctamente dispuestos en el manifiesto generado.

Ahora ha definido una fuente Git repositorya la que Flux puede acceder, pero aún necesita indicarle qué implementar. Flux admite recursos de Kustomizepodinfo , que se exponen en el kustomizedirectorio. Al admitir Kustomizations, Flux no se limita a sí mismo, porque los manifiestos de Kustomize pueden ser tan simples como incluir todos los manifiestos habituales sin cambios.

Cree un Kustomizationmanifiesto que le indique a Flux dónde buscar manifiestos implementables ejecutando el siguiente comando:

flux create kustomization podinfo 
  --source=podinfo 
  --path="./kustomize" 
  --prune=true 
  --validation=client 
  --interval=5m 
  --export  ./clusters/my-cluster/podinfo-kustomization.yaml

Para --source, especifica el podinforepositorio Git que acaba de crear. También establece --path, ./kustomizeque hace referencia a la estructura del sistema de archivos del repositorio de origen. Luego, guarda la salida YAML en un archivo llamado podinfo-kustomization.yamlen el directorio del clúster actual.

Los Git repositoryy Kustomizationque ha creado ya están disponibles, pero el lado del clúster de Flux aún no puede verlos porque no están en el repositorio remoto en GitHub. Para enviarlos, primero debe confirmarlos ejecutando lo siguiente:

git add .  git commit -m "podinfo added"

Con los cambios ahora confirmados, envíelos al repositorio remoto:

git push

Al igual que la última vez, gites posible que le solicite sus credenciales. Ingrese su nombre de usuario y su token de acceso personal para continuar.

Los nuevos manifiestos ya están disponibles y Flux del lado del clúster los recogerá pronto. Puedes ver cómo sincroniza el estado del clúster con el que se presenta en los manifiestos ejecutando lo siguiente:

watch flux get kustomizations

Una vez transcurrido el intervalo de actualización especificado para el Git repositorytiempo transcurrido (que ha establecido 30sen el manifiesto anterior), Flux recuperará su última confirmación y actualizará el clúster. Una vez que lo haga, verá un resultado similar a este:

OutputNAME            READY   MESSAGEflux-system     True    Applied revision: main/fc07af652d3168be329539b30a4c3943a7d12dd8podinfo         True    Applied revision: master/855f7724be13f6146f61a893851522837ad5b634

Puedes ver que podinfose aplicó una personalización, junto con su rama y hash de confirmación. También puedes enumerar las implementaciones y los servicios para comprobar que podinfose han implementado:

kubectl get deployments,services

Verás que están presentes, configurados según sus respectivos manifiestos:

OutputNAME                      READY   UP-TO-DATE   AVAILABLE   AGEdeployment.apps/podinfo   2/2     2            2           56sNAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGEservice/kubernetes   ClusterIP   10.245.0.1      none        443/TCP             34mservice/podinfo      ClusterIP   10.245.78.189   none        9898/TCP,9999/TCP   56s

Cualquier cambio que realices manualmente en estos y otros recursos que Flux controla se sobrescribirá rápidamente con los que se haga referencia a ellos desde los repositorios de Git. Para realizar cambios, deberás modificar las fuentes centrales, no las implementaciones reales en un clúster. Esto también se aplica a la eliminación de recursos: cualquier recurso que elimines manualmente del clúster se restablecerá pronto. Para eliminarlos, deberás quitar sus manifiestos de los repositorios monitoreados y esperar a que se propaguen los cambios.

El comportamiento de Flux es intencionalmente rígido porque opera sobre lo que encuentra en los repositorios remotos al final de cada intervalo de actualización. Suspender la supervisión de Kustomization y, a su vez, la conciliación de estados es útil cuando necesita anular manualmente los recursos en el clúster sin que Flux lo interrumpa.

Puede pausar la monitorización de Kustomizationforma indefinida ejecutando lo siguiente:

flux suspend kustomization kustomization_name

El comportamiento predeterminado se puede recuperar ejecutando flux resumeen pausa Kustomization:

flux resume kustomization kustomization_name

Ahora tienes un proceso automatizado implementado que se implementará podinfoen tu clúster cada vez que se produzca un cambio. Ahora configurarás las notificaciones de Slack para saber cuándo podinfose implementa una nueva versión de.

Paso 3: Configurar las notificaciones de Slack

Ahora que ha configurado podinfoimplementaciones automáticas en su clúster, conectará Flux a un canal de Slack, donde recibirá notificaciones sobre cada implementación y su resultado.

Para integrarlo con Slack, deberá tener un webhook entrante en Slack para su espacio de trabajo. Los webhooks entrantes son una forma de publicar mensajes en el canal de Slack configurado.

Si nunca has creado un webhook, primero tendrás que crear una aplicación para tu espacio de trabajo. Para ello, inicia sesión en Slack y ve a la página de creación de aplicaciones . Pulsa el botón verde Crear nueva aplicación y selecciona Desde cero . Asígnale un nombre flux-app, selecciona el espacio de trabajo deseado y haz clic en Crear nueva aplicación .

Serás redirigido a la página de configuración de la nueva aplicación. Haz clic en Webhooks entrantes en la barra de navegación izquierda.

Habilite los webhooks flux-appactivando el botón junto al título Activar webhooks entrantes .

Más abajo en la página se descubrirá una nueva sección. Desplácese hacia abajo y haga clic en el botón Agregar nuevo webhook al espacio de trabajo . En la página siguiente, seleccione el canal al que desea que se envíen los informes y haga clic en Permitir .

Serás redirigido a la página de configuración de webhooks y verás un nuevo webhook en la tabla. Haz clic en Copiar para copiarlo al portapapeles y tomar nota para usarlo más adelante.

Almacenarás el webhook de Slack generado para tu aplicación en un secreto de Kubernetes en tu clúster, de modo que Flux pueda acceder a él sin especificarlo explícitamente en sus manifiestos de configuración. Almacenar el webhook como secreto también te permite reemplazarlo fácilmente en el futuro.

Crea un secreto llamado slack-urlque contenga el webhook ejecutando el siguiente comando y reemplázalo your_slack_webhookcon la URL que acabas de copiar:

kubectl -n flux-system create secret generic slack-url --from-literal=address=your_slack_webhook

La salida será:

Outputsecret/slack-url created

Ahora creará un proveedor que le permite a Flux comunicarse con el servicio especificado mediante webhooks. Estos leen la URL del webhook desde Secrets, por eso acaba de crear uno. Ejecute el siguiente comando de Flux para crear un proveedor de Slack:

flux create alert-provider slack 
  --type slack 
  --channel general 
  --secret-ref slack-url 
  --export  ./clusters/my-cluster/slack-alert-provider.yaml

Además de Slack, Flux permite comunicarse con Microsoft Teams, Discord y otras plataformas a través de webhooks. También admite el envío de JSON genérico para dar cabida a más software que analiza este formato.

Un proveedor solo permite que Flux envíe mensajes y no especifica cuándo deben enviarse. Para que Flux reaccione a los eventos, deberá crear una alerta mediante el slackproveedor ejecutando lo siguiente:

flux create alert slack-alert 
  --event-severity info 
  --event-source Kustomization/* 
  --event-source GitRepository/* 
  --provider-ref slack 
  --export  ./clusters/my-cluster/slack-alert.yaml

Este comando crea un manifiesto de alerta llamado slack-alertque reaccionará a todos Kustomizationlos Git repositorycambios y los informará al slackproveedor. La gravedad del evento se establece en info, lo que permitirá que la alerta se active en todos los eventos, como la creación o aplicación de manifiestos de Kubernetes, algo que retrasa la implementación o un error que ocurre. Para informar solo errores, puede especificar erroren su lugar. El YAML generado resultante se exporta a un archivo llamado slack-alert.yaml.

Confirme los cambios ejecutando:

git add .  git commit -m "Added Slack alerts"

Envíe los cambios al repositorio remoto ejecutando el siguiente comando, ingresando su nombre de usuario de GitHub y su token de acceso personal si es necesario:

git push

Una vez transcurrido el intervalo de actualización configurado para el repositorio de Git, Flux recuperará y aplicará los cambios. Puede ver cómo la alerta está disponible ejecutando lo siguiente:

watch kubectl -n flux-system get alert

Pronto verás que es Initialized:

OutputNAME          READY   STATUS        AGEslack-alert   True    Initialized   7s

Ahora que las alertas están configuradas, cualquier acción que realice Flux se registrará en el canal de Slack del espacio de trabajo al que está conectado el webhook.

Probarás esta conexión introduciendo un cambio en tu bifurcación de podinfo. Primero, clónala en tu máquina local ejecutando:

git clone https://github.com/$GITHUB_USER/podinfo.git ~/podinfo

Navegar al repositorio clonado:

cd ~/podinfo

Modificarás el nombre de su Servicio, que está definido en ~/podinfo/kustomize/service.yaml. Ábrelo para editarlo:

nano ~/podinfo/kustomize/service.yaml

Modifique el nombre del servicio, de la siguiente manera:

~/podinfo/kustomize/servicio.yaml

apiVersion: v1kind: Servicemetadata:  name: podinfo-1spec:  type: ClusterIP  selector:    app: podinfo  ports:    - name: http      port: 9898      protocol: TCP      targetPort: http    - port: 9999      targetPort: grpc      protocol: TCP      name: grpc

Guarde y cierre el archivo, luego confirme los cambios ejecutando:

git add .  git commit -m "Service name modified"

Luego, inserta los cambios:

git push

Después de unos minutos, verás que los cambios aparecen en Slack a medida que se implementan:

Flux obtuvo la nueva confirmación, creó un nuevo servicio llamado podinfo-1, lo configuró y eliminó el anterior. Este orden de acciones garantiza que el servicio anterior (o cualquier otro manifiesto) permanezca intacto si falla el aprovisionamiento del nuevo.

En caso de que la nueva revisión de los manifiestos observados contenga un error de sintaxis, Flux informará un error:

Conectaste Flux a tu espacio de trabajo de Slack y recibirás notificaciones inmediatas de todas las acciones e implementaciones que se realicen. Ahora configurarás Flux para supervisar las versiones de Helm.

Paso 4 (opcional): automatización de las implementaciones de versiones de Helm

Además de supervisar las configuraciones personalizadas y los repositorios de Git, Flux también puede supervisar los gráficos de Helm. Flux puede supervisar los gráficos que residen en los repositorios de Git o Helm, así como en el almacenamiento en la nube de S3. Ahora lo configurará para que supervise el podinfográfico, que se encuentra en un repositorio de Helm.

El proceso de indicarle a Flux que monitoree un gráfico de Helm es similar al que realizó en el paso 2. Primero deberá definir una fuente que pueda sondear para detectar cambios (de uno de los tres tipos mencionados anteriormente). Luego, especificará qué gráfico implementar realmente entre los que encuentre creando un HelmRelease .

Navegar de nuevo al flux-configrepositorio:

cd ~/flux-config

Ejecute el siguiente comando para crear una fuente para el repositorio Helm que contenga podinfo:

flux create source helm podinfo 
  --url=https://stefanprodan.github.io/podinfo 
  --interval=10m 
  --export  ./clusters/my-cluster/podinfo-helm-repo.yaml

Aquí se especifica la URL del repositorio y la frecuencia con la que se debe verificar. Luego, se guarda el resultado en un archivo llamado podinfo-helm-repo.yaml.

Una vez definido el repositorio de origen, puedes crear un HelmRelease y definir qué gráfico monitorear:

flux create hr podinfo 
  --interval=10m 
  --source=HelmRepository/podinfo 
  --chart=podinfo 
  --target-namespace=podinfo-helm 
  --export  ./clusters/my-cluster/podinfo-helm-chart.yaml

Al igual que en el comando anterior, guarda la salida YAML resultante en un archivo, aquí llamado podinfo-helm-chart.yaml. También pasa el nombre del gráfico ( podinfo), establece el --sourceen el repositorio que acaba de definir y especifica que el espacio de nombres en el que se instalará el gráfico es podinfo-helm.

Dado que el podinfo-helmespacio de nombres no existe, créelo ejecutando:

kubectl create namespace podinfo-helm

Luego, confirma y envía los cambios:

git add .  git commit -m "Added podinfo Helm chart"  git push

Después de unos minutos, verás que Flux registró una actualización exitosa del gráfico de Helm en Slack:

Puede comprobar los pods contenidos en el podinfo-helmespacio de nombres ejecutando:

kubectl get pods -n podinfo-helm

La salida será similar a esto:

OutputNAME                                     READY   STATUS    RESTARTS   AGEpodinfo-chart-podinfo-7c9b7667cb-gshkb   1/1     Running   0          33s

Esto significa que ha configurado correctamente Flux para supervisar e implementar el podinfográfico de Helm. Tan pronto como se publique una nueva versión o se envíe una modificación, Flux recuperará e implementará la variante más reciente del gráfico de Helm.

Conclusión

Ahora ha automatizado las implementaciones de manifiestos de Kubernetes con Flux, lo que le permite enviar confirmaciones a repositorios supervisados ​​y hacer que se apliquen automáticamente a su clúster. También ha configurado alertas en Slack, por lo que siempre sabrá qué implementaciones se están realizando en tiempo real y podrá buscar las anteriores y ver los errores que puedan haberse producido.

Además de GitHub, Flux también permite recuperar y arrancar repositorios de Git alojados en GitLab. Puedes visitar la documentación oficial para obtener más información.