Información acerca de los paquetes de flota

Vista previa

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

En esta página, se explican los paquetes de flota, la API de FleetPackage y cómo se relacionan con el Sincronizador de configuración.

Un FleetPackage es una API declarativa que te permite administrar paquetes en una flota. Un paquete de flota es un conjunto de manifiestos YAML de Kubernetes que definen la configuración del clúster. Cuando usas paquetes de flota, puedes implementar paquetes a través de un lanzamiento progresivo o todo a la vez en los clústeres registrados en tu flota.

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

Beneficios

Usa paquetes de flota para implementar recursos de Kubernetes en clústeres que están 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 en el repositorio de Git en el clúster nuevo. Los paquetes de flota se basan en los beneficios del Sincronizador de configuración, como la corrección automática de la deriva, y ofrecen las siguientes ventajas únicas:

• Lanzamiento de recursos automatizado: 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.

• Configura clústeres nuevos automáticamente: Si configuras un paquete de flota y, luego, agregas clústeres nuevos a una flota, los recursos que define el paquete de flota se implementan automáticamente en el clúster nuevo.

• Administra la configuración de Kubernetes a gran escala: En lugar de administrar clústeres uno por uno, usa paquetes de flota para implementar recursos en una flota completa de clústeres.

• Minimiza el impacto de los cambios incorrectos: Elige una cantidad máxima de clústeres en los que implementar recursos a la vez. Puedes supervisar de cerca los cambios en cada clúster para asegurarte de que los cambios incorrectos no afecten a toda la flota.

• Simplifica la configuración del Sincronizador de configuración: 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.

Es posible que prefieras usar el Sincronizador de configuración con objetos RootSync o RepoSync en lugar de paquetes de flota si se aplica una o más de las siguientes situaciones:

• Administras una pequeña cantidad 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 cuando se configura 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: Crea repositorios WET.

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

Arquitectura

Puedes usar la API de FleetPackage para implementar manifiestos de Kubernetes en una flota de clústeres. La API de FleetPackage usa Cloud Build para sincronizar y recuperar recursos de Kubernetes desde tu repositorio de Git. Luego, el servicio de paquetes de flota implementa esos recursos en tus clústeres.

Ejemplos de casos de uso

Puedes usar paquetes de flota para implementar recursos de 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 Implementa paquetes de flota.

Deployment en todos los clústeres de una flota

El siguiente FleetPackage usa una estrategia continua para implementar recursos de Kubernetes en tres clústeres a la vez y se orienta 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

Deployment en un subconjunto de clústeres

El siguiente FleetPackage usa un selector de etiquetas para implementar recursos de Kubernetes solo en clústeres con la etiqueta de membresía 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

Deployment de recursos de variantes en un clúster

En este ejemplo, en tu repositorio de Git, tienes una carpeta llamada "implementaciones" que contiene dos especificaciones de implementación diferentes:

Replicas: 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
    

Replicas: 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 "pequeñas" o "grandes" en diferentes clústeres. Cada clúster tiene una etiqueta de nginx-size=small o nginx-size=large.

El FleetPackage de este ejemplo se parecería 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']}

¿Qué sigue?

Implementa paquetes de flota