Acerca de los paquetes de flotas

En esta página se explican los paquetes de flota, la API FleetPackage y su relación con Config Sync.

Una FleetPackage es una API declarativa que te permite gestionar paquetes en una flota. Un paquete de flota es un conjunto de manifiestos YAML de Kubernetes que definen la configuración del clúster. Si usas paquetes de flota, puedes implementar paquetes de forma simultánea o progresiva en los clústeres registrados en tu flota.

Defines cada objeto FleetPackage una vez y, a continuación, puedes actualizar ese paquete con una nueva revisión. Cuando aplicas una nueva revisión, el servicio de paquetes de la flota recoge esos cambios y los implementa en tus clústeres.

Ventajas

Usa paquetes de flotas para desplegar recursos de Kubernetes en clústeres registrados en una flota. Después de crear y aplicar un paquete de flota, este implementa automáticamente los archivos de configuración de Kubernetes del repositorio Git en el nuevo clúster. Los paquetes de flotas se basan en las ventajas de Config Sync, como la corrección automática de las desviaciones, y ofrecen las siguientes ventajas únicas:

• Automatizar el lanzamiento de recursos: después de configurar un paquete de flota, el servicio de paquetes de flota implementa automáticamente los recursos de Kubernetes a los que apunta en todos los clústeres.

• Configurar clústeres nuevos automáticamente: si configuras un paquete de flota y, más adelante, añades clústeres nuevos a una flota, los recursos definidos por el paquete de flota se implementarán automáticamente en el clúster nuevo.

• Gestionar la configuración de Kubernetes a gran escala: en lugar de gestionar los clústeres uno a uno, usa paquetes de flotas para desplegar recursos en toda una flota de clústeres.

• Minimizar el impacto de los cambios incorrectos: elige un número máximo de clústeres en los que implementar recursos a la vez. Puedes monitorizar de cerca los cambios de cada clúster para asegurarte de que los cambios incorrectos no afecten a toda tu flota.

• Simplifica la configuración de Config Sync: los paquetes de flota usan Cloud Build para autenticarse en Git, lo que significa que te autenticas una vez por proyecto en lugar de una vez por objeto RootSync o RepoSync.

Puede que prefieras usar Config Sync con objetos RootSync u RepoSync en lugar de paquetes de flota si se da uno o varios de los siguientes casos:

• Gestionas un número reducido de clústeres.

• Necesitas más control sobre cómo se implementan los recursos en tus clústeres, más allá de lo que proporciona la API del paquete de flota con etiquetas y variantes.

Requisitos y limitaciones

• Solo se admiten repositorios de Git como fuente de información principal al configurar un paquete de flota.

• Los recursos de Kubernetes almacenados en Git deben representar el estado final del recurso. No se admiten superposiciones adicionales para transformar el recurso almacenado en Git. Para obtener más información sobre las diferencias entre estos recursos, consulta Práctica recomendada: crear repositorios WET.

• La API FleetPackage solo está disponible en la región us-central1. Puedes seguir desplegando en clústeres de diferentes regiones, pero debes configurar Cloud Build y la CLI de gcloud en us-central1.

Arquitectura

Puedes usar la API FleetPackage para desplegar manifiestos de Kubernetes en una flota de clústeres. La API FleetPackage usa Cloud Build para sincronizar y obtener recursos de Kubernetes de tu repositorio de Git. A continuación, el servicio de paquetes de la flota implementa esos recursos en tus clústeres.

Ejemplos de casos prácticos

Puedes usar paquetes de flotas para desplegar recursos desde un repositorio de Git en toda tu flota de clústeres. También puedes configurar tu paquete de flota para controlar cómo, dónde y qué tipo de recursos se implementan.

En la siguiente sección se muestran ejemplos de diferentes configuraciones de FleetPackage. Para obtener información más detallada sobre cómo aplicar paquetes de flota, consulta Implementar paquetes de flota.

Despliegue en todos los clústeres de una flota

El siguiente FleetPackage usa una estrategia de lanzamiento gradual para desplegar recursos de Kubernetes en tres clústeres a la vez y se dirige a todos los clústeres de una flota:

resourceBundleSelector:
  cloudBuildRepository:
    name: projects/my-project/locations/us-central1/connections/my-connection/repositories/my-repo
    tag: v1.0.0
    serviceAccount: projects/my-project/serviceAccounts/[e-mail]
target:
  fleet:
    project: projects/my-project
rolloutStrategy:
  rolling:
    maxConcurrent: 3

Despliegue en un subconjunto de clústeres

El siguiente FleetPackage usa un selector de etiquetas para desplegar recursos de Kubernetes solo en clústeres con la etiqueta de pertenencia country que coincida con "us" en la flota:

resourceBundleSelector:
  cloudBuildRepository:
    name: projects/my-project/locations/us-central1/connections/my-connection/repositories/my-repo
    tag: v1.0.0
    serviceAccount: projects/my-project/serviceAccounts/[e-mail]
target:
  fleet:
    project: projects/my-project
    selector:
      matchLabels:
        country: "us"
rolloutStrategy:
  rolling:
    maxConcurrent: 3

Despliegue de recursos de variantes en un clúster

En este ejemplo, en tu repositorio de Git, tienes una carpeta llamada "deployments" (despliegues) que contiene dos especificaciones de despliegue diferentes:

Réplicas: 3

    # small.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-deployment
      labels:
        app: nginx
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.14.2
            ports:
            - containerPort: 80
    

Réplicas: 10

    # large.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-deployment
      labels:
        app: nginx
    spec:
      replicas: 10
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.14.2
            ports:
            - containerPort: 80
    

Puedes usar variantes para implementar las implementaciones "small" o "large" en diferentes clústeres. Cada clúster tiene una etiqueta nginx-size=small o nginx-size=large.

El FleetPackage de este ejemplo sería similar al siguiente:

resourceBundleSelector:
  cloudBuildRepository:
    name: projects/my-project/locations/us-central1/connections/my-connection/repositories/my-repo
    tag: v1.0.0
    serviceAccount: projects/my-project/serviceAccounts/[e-mail]
    path: deployments
    variantsPattern: "*.yaml"
rolloutStrategy:
  rolling:
    maxConcurrent: 2
target:
  fleet:
    project: projects/my-project
variantSelector:
  variantNameTemplate: ${membership.labels['nginx-size']}

Siguientes pasos

Implementar paquetes de flotas