Acerca dos pacotes de frotas

Esta página explica os pacotes de frotas, a API FleetPackage e a respetiva relação com o Config Sync.

Uma FleetPackage é uma API declarativa que lhe permite gerir pacotes numa frota. Um pacote de frota é um conjunto de manifestos YAML do Kubernetes que definem a configuração do cluster. Ao usar pacotes de frota, pode implementar pacotes através de uma implementação total ou progressiva em clusters registados na sua frota.

Define cada objeto FleetPackage uma vez e, em seguida, pode atualizar esse pacote com uma nova revisão. Quando aplica uma nova revisão, o serviço de pacotes da frota seleciona essas alterações e implementa-as nos seus clusters.

Vantagens

Use pacotes de frotas para implementar recursos do Kubernetes em clusters que estão registados numa frota. Depois de criar e aplicar um pacote de frota, o pacote de frota implementa automaticamente os ficheiros de configuração do Kubernetes no repositório Git para o novo cluster. Os pacotes de frotas baseiam-se nas vantagens do Config Sync, como a correção automática de desvios, e oferecem as seguintes vantagens únicas:

• Automatize a implementação de recursos: depois de configurar um pacote de frota, os recursos do Kubernetes para os quais aponta são implementados automaticamente pelo serviço de pacotes de frotas em todos os clusters.

• Configurar novos clusters automaticamente: se configurar um pacote de frota e, posteriormente, adicionar novos clusters a uma frota, todos os recursos definidos pelo pacote de frota são implementados automaticamente no novo cluster.

• Faça a gestão da configuração do Kubernetes em grande escala: em vez de gerir clusters individualmente, use pacotes de frotas para implementar recursos numa frota inteira de clusters.

• Minimize o impacto de alterações incorretas: escolha um número máximo de clusters para implementar recursos de uma só vez. Pode monitorizar atentamente as alterações a cada cluster para garantir que as alterações incorretas não afetam toda a sua frota.

• Simplifique a configuração da sincronização de configuração: os pacotes de frotas usam o Cloud Build para autenticar no Git, o que significa que se autentica uma vez por projeto em vez de uma vez por objeto RootSync ou RepoSync.

Pode preferir usar a sincronização de configuração com objetos RootSync ou RepoSync em vez de pacotes de frotas se um ou mais dos seguintes cenários se aplicar a si:

• Gerir um pequeno número de clusters.

• Precisa de mais controlo sobre a forma como os recursos são implementados nos seus clusters, além do que a API Fleet Package oferece com etiquetas e variantes.

Requisitos e limitações

• Apenas os repositórios Git são suportados como a fonte de verdade quando configura um pacote de frota.

• Os recursos do Kubernetes armazenados no Git têm de representar o estado final do recurso. As sobreposições adicionais para transformar o recurso armazenado no Git não são suportadas. Para mais informações sobre as diferenças nestes recursos, consulte o artigo Prática recomendada: crie repositórios WET.

• A API FleetPackage só está disponível na região us-central1. Ainda pode implementar em clusters em diferentes regiões, mas tem de configurar o Cloud Build e configurar a CLI gcloud em us-central1.

Arquitetura

Pode usar a API FleetPackage para implementar manifestos do Kubernetes numa frota de clusters. A API FleetPackage usa o Cloud Build para sincronizar e obter recursos do Kubernetes do seu repositório Git. O serviço de pacote de frotas implementa esses recursos nos seus clusters.

Exemplos de utilização

Pode usar pacotes de frotas para implementar recursos de um repositório Git em toda a sua frota de clusters. Também pode configurar o pacote da frota para controlar como, onde e que tipo de recursos são implementados.

A secção seguinte mostra exemplos de diferentes configurações de FleetPackage. Para obter informações mais detalhadas sobre a aplicação de pacotes de frotas, consulte o artigo Implemente pacotes de frotas.

Implementação em todos os clusters numa frota

O seguinte FleetPackage usa uma estratégia de implementação contínua para implementar recursos do Kubernetes em três clusters de cada vez e segmenta todos os clusters numa frota:

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

Implementação num subconjunto de clusters

O seguinte FleetPackage usa um seletor de etiquetas para implementar recursos do Kubernetes apenas em clusters com a etiqueta de associação country que corresponde a "us" na frota:

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

Implementação de recursos variantes num cluster

Para este exemplo, no seu repositório Git, tem uma pasta denominada "deployments" que contém duas especificações de implementação 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
    

Pode usar variantes para implementar as implementações "pequenas" ou "grandes" em diferentes clusters. Cada cluster tem uma etiqueta de nginx-size=small ou nginx-size=large.

O FleetPackage neste exemplo seria semelhante ao seguinte:

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']}

O que se segue?

Implemente pacotes de frota