Kubernetes@1 – Tarefa Kubectl v1

Implante, configure e atualize um cluster do Kubernetes no Serviço de Contêiner do Azure executando comandos kubectl.

Syntax

# Kubectl v1
# Deploy, configure, update a Kubernetes cluster in Azure Container Service by running kubectl commands.
- task: Kubernetes@1
  inputs:
  # Kubernetes Cluster
    #connectionType: 'Kubernetes Service Connection' # 'Azure Resource Manager' | 'Kubernetes Service Connection' | 'None'. Required when command != logout. Service connection type. Default: Kubernetes Service Connection.
    #kubernetesServiceEndpoint: # string. Required when connectionType = Kubernetes Service Connection && command != logout. Kubernetes service connection. 
    #azureSubscriptionEndpoint: # string. Required when connectionType = Azure Resource Manager && command != logout. Azure subscription. 
    #azureResourceGroup: # string. Required when connectionType = Azure Resource Manager && command != logout. Resource group. 
    #kubernetesCluster: # string. Required when connectionType = Azure Resource Manager && command != logout. Kubernetes cluster. 
    #useClusterAdmin: false # boolean. Optional. Use when connectionType = Azure Resource Manager && command != logout. Use cluster admin credentials. Default: false.
    #namespace: # string. Optional. Use when command != logout. Namespace. 
  # Commands
    #command: # 'apply' | 'create' | 'delete' | 'exec' | 'expose' | 'get' | 'login' | 'logout' | 'logs' | 'run' | 'set' | 'top'. Command. 
    #useConfigurationFile: false # boolean. Optional. Use when command != login && command != logout. Use configuration. Default: false.
    #configurationType: 'configuration' # 'configuration' | 'inline'. Optional. Use when useConfigurationFile = true. Configuration type. Default: configuration.
    configuration: # string. Required when configurationType = configuration. File path. 
    #inline: # string. Required when configurationType = inline. Inline configuration. 
    #arguments: # string. Optional. Use when command != login && command != logout. Arguments. 
  # Secrets
    #secretType: 'dockerRegistry' # 'dockerRegistry' | 'generic'. Required when command != login && command != logout. Type of secret. Default: dockerRegistry.
    #secretArguments: # string. Optional. Use when secretType = generic && command != login && command != logout. Arguments. 
    #containerRegistryType: 'Azure Container Registry' # 'Azure Container Registry' | 'Container Registry'. Required when secretType = dockerRegistry && command != login && command != logout. Container registry type. Default: Azure Container Registry.
    #dockerRegistryEndpoint: # string. Optional. Use when secretType = dockerRegistry && containerRegistryType = Container Registry && command != login && command != logout. Docker registry service connection. 
    #azureSubscriptionEndpointForSecrets: # string. Optional. Use when secretType = dockerRegistry && containerRegistryType = Azure Container Registry && command != login && command != logout. Azure subscription. 
    #azureContainerRegistry: # string. Optional. Use when secretType = dockerRegistry && containerRegistryType = Azure Container Registry && command != login && command != logout. Azure container registry. 
    #secretName: # string. Optional. Use when command != login && command != logout. Secret name. 
    #forceUpdate: true # boolean. Optional. Use when command != login && command != logout. Force update secret. Default: true.
  # ConfigMaps
    #configMapName: # string. Optional. Use when command != login && command != logout. ConfigMap name. 
    #forceUpdateConfigMap: false # boolean. Optional. Use when command != login && command != logout. Force update configmap. Default: false.
    #useConfigMapFile: false # boolean. Optional. Use when command != login && command != logout. Use file. Default: false.
    #configMapFile: # string. Required when useConfigMapFile = true && command != login && command != logout. ConfigMap file. 
    #configMapArguments: # string. Optional. Use when useConfigMapFile = false && command != login && command != logout. Arguments. 
  # Advanced
    #versionOrLocation: 'version' # 'version' | 'location'. Kubectl. Default: version.
    #versionSpec: '1.13.2' # string. Optional. Use when versionOrLocation = version. Version spec. Default: 1.13.2.
    #checkLatest: false # boolean. Optional. Use when versionOrLocation = version. Check for latest version. Default: false.
    #specifyLocation: # string. Required when versionOrLocation = location. Path to kubectl. 
    #workingDirectory: '$(System.DefaultWorkingDirectory)' # string. Alias: cwd. Working directory. Default: $(System.DefaultWorkingDirectory).
    #outputFormat: 'json' # 'json' | 'yaml' | 'none'. Output format. Default: json.

Entradas

connectionType - Tipo de conexão de serviço
string. Obrigatório quando command != logout. Valores permitidos: Azure Resource Manager, Kubernetes Service Connection, None. Valor padrão: Kubernetes Service Connection.

Especifica o tipo de conexão de serviço: Resource Manager do Azure ao usar Serviço de Kubernetes do Azure ou Conexão de Serviço do Kubernetes para qualquer outro cluster.

• Kubernetes Service Connection – Permite que você forneça um arquivo KubeConfig, especifique uma Conta de Serviço ou importe uma instância do AKS com a opção Assinatura do Azure . Importar uma instância do AKS com a opção Assinatura do Azure requer acesso ao cluster do Kubernetes no momento da configuração da Conexão de Serviço.
• Azure Resource Manager – Permite selecionar uma instância do AKS. Não acessa o cluster do Kubernetes no momento da configuração da Conexão de Serviço.
• None – Use uma configuração pré-criada do Kubernetes armazenada localmente.

Para obter mais informações, consulte Conexão de serviço na seção Comentários a seguir.

kubernetesServiceEndpoint - Conexão de serviço do Kubernetes
string. Obrigatório quando connectionType = Kubernetes Service Connection && command != logout.

Selecione uma conexão de serviço do Kubernetes.

azureSubscriptionEndpoint - Assinatura do Azure
string. Obrigatório quando connectionType = Azure Resource Manager && command != logout.

Especifica a assinatura de Resource Manager do Azure, que contém o Registro de Contêiner do Azure.

Observação

Para configurar uma nova conexão de serviço, especifique a assinatura do Azure na lista e clique Authorizeem . Se sua assinatura não estiver listada ou se você quiser usar uma entidade de serviço existente, você poderá configurar uma conexão de serviço do Azure usando os Add botões ou Manage .

azureResourceGroup - Grupo de recursos
string. Obrigatório quando connectionType = Azure Resource Manager && command != logout.

Selecione um grupo de recursos do Azure.

kubernetesCluster - Cluster do Kubernetes
string. Obrigatório quando connectionType = Azure Resource Manager && command != logout.

Selecione um cluster gerenciado do Azure.

useClusterAdmin - Usar credenciais de administrador de cluster
boolean. Opcional. Use quando connectionType = Azure Resource Manager && command != logout. Valor padrão: false.

Use credenciais de administrador de cluster em vez de credenciais de usuário de cluster padrão.

namespace - Namespace
string. Opcional. Use quando command != logout.

Defina o namespace para o comando kubectl usando o sinalizador –namespace. Se o namespace não for fornecido, os comandos serão executados no namespace padrão.

command - Comando
string. Valores permitidos: apply, create, , delete, exposeexec, get, login, logout, logs, run, , set, . top

Selecione ou especifique um comando kubectl a ser executado. A lista de valores permitidos fornece algumas opções comuns para facilitar a seleção ao usar a tarefa assistente, mas você pode especificar outros comandos kubectl, como scale. Use a arguments entrada para especificar parâmetros adicionais para o comando especificado kubectl .

useConfigurationFile - Usar configuração
boolean. Opcional. Use quando command != login && command != logout. Valor padrão: false.

Especifica a configuração do Kubernetes a ser usada com o kubectl comando . O script embutido, o nome do arquivo, o diretório ou a URL para arquivos de configuração do Kubernetes podem ser fornecidos.

configurationType - Tipo de configuração
string. Opcional. Use quando useConfigurationFile = true. Valores permitidos: configuration (Caminho do arquivo), inline (configuração embutida). Valor padrão: configuration.

Especifica o tipo de configuração do Kubernetes para o kubectl comando . Pode ser um caminho de arquivo ou um script embutido.

configuration - Caminho do arquivo
string. Obrigatório quando configurationType = configuration.

Especifica o nome do arquivo, o diretório ou a URL para arquivos de configuração do kubernetes usados com os comandos.

inline - Configuração embutida
string. Obrigatório quando configurationType = inline.

Especifica a configuração de implantação embutida para o kubectl comando .

arguments - Argumentos
string. Opcional. Use quando command != login && command != logout.

Argumentos para o comando kubectl especificado.

secretType - Tipo de segredo
string. Obrigatório quando command != login && command != logout. Valores Permitidos: dockerRegistry e generic. Valor padrão: dockerRegistry.

Criar/atualizar uma imagem genérica ou dockerpullsecret. Selecione dockerRegistry para criar/atualizar o imagepullsecret do registro selecionado. Um imagePullSecret é uma maneira de passar um segredo que contém uma senha do registro de contêiner para o Kubelet para que ele possa efetuar pull de uma imagem privada em nome do pod.

secretArguments - Argumentos
string. Opcional. Use quando secretType = generic && command != login && command != logout.

Especifica as chaves e os valores literais a serem inseridos em segredo. Por exemplo, --from-literal=key1=value1ou --from-literal=key2="top secret".

containerRegistryType - Tipo de registro de contêiner
string. Obrigatório quando secretType = dockerRegistry && command != login && command != logout. Valores Permitidos: Azure Container Registry e Container Registry. Valor padrão: Azure Container Registry.

Selecione um tipo de Registro de contêiner. A tarefa pode usar detalhes da Assinatura do Azure para trabalhar com um Registro de Contêiner do Azure. Também há suporte para outros registros de contêiner padrão.

dockerRegistryEndpoint - Conexão do serviço de registro do Docker
string. Opcional. Use quando secretType = dockerRegistry && containerRegistryType = Container Registry && command != login && command != logout.

Selecione uma conexão de serviço do Registro do Docker. Obrigatório para comandos que precisam ser autenticados com um registro.

azureSubscriptionEndpointForSecrets - Assinatura do Azure
string. Opcional. Use quando secretType = dockerRegistry && containerRegistryType = Azure Container Registry && command != login && command != logout.

Especifica a assinatura de Resource Manager do Azure, que contém Registro de Contêiner do Azure.

Observação

Para configurar uma nova conexão de serviço, selecione a assinatura do Azure na lista e clique Authorizeem . Se sua assinatura não estiver listada ou se você quiser usar uma entidade de serviço existente, você poderá configurar uma conexão de serviço do Azure usando os Add botões ou Manage .

azureContainerRegistry - Registro de contêiner do Azure
string. Opcional. Use quando secretType = dockerRegistry && containerRegistryType = Azure Container Registry && command != login && command != logout.

Especifica um Registro de Contêiner do Azure que é usado para extrair imagens de contêiner e implantar aplicativos no cluster do Kubernetes. Obrigatório para comandos que precisam ser autenticados com um registro.

secretName - Nome do segredo
string. Opcional. Use quando command != login && command != logout.

Nome do segredo. Você pode usar esse nome de segredo no arquivo de configuração YAML do Kubernetes.

forceUpdate - Forçar segredo de atualização
boolean. Opcional. Use quando command != login && command != logout. Valor padrão: true.

Exclua o segredo se ele existir e crie um novo com valores atualizados.

configMapName - Nome do ConfigMap
string. Opcional. Use quando command != login && command != logout.

Os ConfigMaps permitem que você desacopla artefatos de configuração do conteúdo da imagem para manter os aplicativos em contêineres portáteis.

forceUpdateConfigMap - Forçar o configmap de atualização
boolean. Opcional. Use quando command != login && command != logout. Valor padrão: false.

Exclua o configmap se ele existir e crie um novo com valores atualizados.

useConfigMapFile - Usar arquivo
boolean. Opcional. Use quando command != login && command != logout. Valor padrão: false.

Cria um ConfigMap de um arquivo individual ou de vários arquivos especificando um diretório.

configMapFile - Arquivo ConfigMap
string. Obrigatório quando useConfigMapFile = true && command != login && command != logout.

Especifique um arquivo ou diretório que contenha o configMaps.

configMapArguments - Argumentos
string. Opcional. Use quando useConfigMapFile = false && command != login && command != logout.

Especifica as chaves e os valores literais a serem inseridos em configMap. Por exemplo, --from-literal=key1=value1 ou --from-literal=key2="top secret".

versionOrLocation - Kubectl
string. Valores permitidos: version, location (Especificar local). Valor padrão: version.

kubectl é uma interface de linha de comando para executar comandos em clusters do Kubernetes.

versionSpec - Especificação de versão
string. Opcional. Use quando versionOrLocation = version. Valor padrão: 1.13.2.

Especifica a especificação de versão da versão a ser obtido. Exemplos: 1.7.0, 1.x.0, 4.x.0, 6.10.0, >=6.10.0.

checkLatest - Verificar a versão mais recente
boolean. Opcional. Use quando versionOrLocation = version. Valor padrão: false.

Sempre verifica online a versão mais recente disponível (stable.txt) que satisfaz a especificação de versão. Normalmente, isso é falso, a menos que você tenha um cenário específico para sempre obter o mais recente. Isso fará com que ele incorrerá em custos de download quando potencialmente não for necessário, especialmente com o pool de build hospedado.

specifyLocation - Caminho para kubectl
string. Obrigatório quando versionOrLocation = location.

Especifica o caminho completo para o kubectl.exe arquivo.

workingDirectory - Diretório de trabalho
Alias de entrada: cwd. string. Valor padrão: $(System.DefaultWorkingDirectory).

Diretório de trabalho para o comando Kubectl.

outputFormat - Formato de saída
string. Valores permitidos: json, yaml, none. Valor padrão: json.

Formato de saída.

Opções de controle da tarefa

Todas as tarefas têm opções de controle além de suas entradas de tarefa. Para obter mais informações, consulte Opções de controle e propriedades comuns da tarefa.

Variáveis de saída

Essa tarefa define as variáveis de saída a seguir, que você pode consumir em etapas downstream, trabalhos e estágios.

KubectlOutput
Armazena a saída do kubectl comando.

Comentários

Novidades na versão 1.0.

• Adicionada uma nova entrada de tipo de conexão de serviço para uma seleção fácil de clusters do AKS do Azure.
• Substituimos a entrada da variável de saída por uma seção de variáveis de saída que adicionamos em todas as tarefas.

Use essa tarefa para implantar, configurar ou atualizar um cluster do Kubernetes executando comandos kubectl.

Conexão de serviço

A tarefa funciona com dois tipos de conexão de serviço: Azure Resource Manager e Conexão de Serviço do Kubernetes, descrito abaixo.

Azure Resource Manager

Defina connectionType como Azure Resource Manager e especifique um azureSubscriptionEndpoint para usar uma conexão de serviço do Azure Resource Manager.

Este exemplo YAML mostra como o Azure Resource Manager é usado para se referir ao cluster do Kubernetes. Isso deve ser usado com um dos comandos kubectl e os valores apropriados exigidos pelo comando.

variables:
  azureSubscriptionEndpoint: Contoso
  azureContainerRegistry: contoso.azurecr.io
  azureResourceGroup: Contoso
  kubernetesCluster: Contoso
  useClusterAdmin: false

steps:
- task: Kubernetes@1
  displayName: kubectl apply
  inputs:
    connectionType: Azure Resource Manager
    azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
    azureResourceGroup: $(azureResourceGroup)
    kubernetesCluster: $(kubernetesCluster)
    useClusterAdmin: $(useClusterAdmin)

Conexão de Serviço do Kubernetes

Defina connectionType como Kubernetes Service Connection e especifique um kubernetesServiceEndpoint para usar uma conexão de serviço do Kubernetes.

Este exemplo YAML mostra como uma Conexão de Serviço Kubernetes é usada para se referir ao cluster Kubernetes. Isso deve ser usado com um dos comandos kubectl e os valores apropriados exigidos pelo comando.

- task: Kubernetes@1
  displayName: kubectl apply
  inputs:
    connectionType: Kubernetes Service Connection
    kubernetesServiceEndpoint: Contoso

Considerações sobre a Conexão de Serviço do Kubernetes ao acessar o AKS

Você pode criar uma conexão de serviço do Kubernetes com qualquer uma das opções a seguir.

• KubeConfig
• Conta de serviço
• Assinatura do Azure

Ao selecionar a opção Assinatura do Azure , o Kubernetes precisa estar acessível ao Azure DevOps no momento da configuração da conexão de serviço. Pode haver vários motivos pelos quais uma conexão de serviço não pode ser criada, por exemplo, você criou um cluster privado ou o cluster tem contas locais desabilitadas. Nesses casos, o Azure DevOps não pode se conectar ao cluster no momento da configuração da conexão de serviço e você verá uma tela carregando namespaces paralisada.

A partir do Kubernetes 1.24, os tokens de longa duração não são mais criados por padrão. O Kubernetes recomenda não usar tokens de longa duração. Como resultado, as tarefas que usam uma conexão de serviço do Kubernetes criada com a opção Assinatura do Azure não têm acesso ao token permanente necessário para autenticar e não podem acessar o cluster do Kubernetes. Isso também resulta na caixa de diálogo Carregar namespaces congelados .

Usar a Conexão de Serviço Resource Manager do Azure para acessar o AKS

Para clientes do AKS, o tipo de conexão de serviço do Azure Resource Manager fornece o melhor método para se conectar a um cluster privado ou um cluster que tem contas locais desabilitadas. Esse método não depende da conectividade de cluster no momento em que você cria uma conexão de serviço. O acesso ao AKS é adiado para o runtime de pipeline, que tem as seguintes vantagens:

• O acesso a um cluster do AKS (privado) pode ser executado de um agente auto-hospedado ou de conjunto de dimensionamento com linha de visão para o cluster.
• Um token é criado para cada tarefa que usa uma conexão de serviço do Azure Resource Manager. Isso garante que você esteja se conectando ao Kubernetes com um token de curta duração, que é a recomendação do Kubernetes.
• O AKS pode ser acessado mesmo quando as contas locais estão desabilitadas.

Perguntas frequentes sobre a conexão de serviço

Recebo a seguinte mensagem de erro: Não foi possível localizar nenhum segredo associado à conta de serviço. O que está acontecendo?

Você está usando a opção Conexão de serviço do Kubernetes com a Assinatura do Azure. Estamos atualizando esse método para criar tokens de longa duração. Espera-se que isso esteja disponível em meados de maio. No entanto, é recomendável começar a usar o tipo de conexão de serviço do Azure e não usar tokens de longa duração de acordo com as diretrizes do Kubernetes.

Estou usando o AKS e não quero alterar nada, posso continuar a usar tarefas com a conexão de serviço do Kubernetes?

Estamos atualizando esse método para criar tokens de longa duração. Espera-se que isso esteja disponível em meados de maio. No entanto, lembre-se de que essa abordagem é contra as diretrizes do Kubernetes.

Estou usando as tarefas do Kubernetes e a conexão de serviço do Kubernetes, mas não o AKS. Devo me preocupar?

As tarefas continuarão funcionando como antes.

O tipo de conexão do serviço kubernetes será removido?

Nossas tarefas do Kubernetes funcionam com qualquer cluster do Kubernetes, independentemente de onde estão sendo executadas. A conexão de serviço do Kubernetes continuará a existir.

Sou um cliente do AKS e tudo está funcionando bem, devo agir?

Não há necessidade de mudar nada. Se você estiver usando a conexão de serviço do Kubernetes e a Assinatura do Azure selecionada durante a criação, deverá estar ciente das diretrizes do Kubernetes sobre como usar tokens de longa duração.

Estou criando um Ambiente do Kubernetes e não tenho nenhuma opção para usar conexões de serviço

Caso não seja possível acessar o AKS durante o tempo de criação do ambiente, você pode usar um ambiente vazio e definir a connectionType entrada para uma conexão de serviço do Azure Resource Manager.

Tenho o AKS configurado com o RBAC do Azure Active Directory e meu pipeline não funciona. Essas atualizações resolve isso?

Acessar o Kubernetes quando o RBAC do AAD está habilitado não está relacionado à criação de token. Para evitar um prompt interativo, daremos suporte ao kubelogin em uma atualização futura.

Comandos

A entrada de comando aceita comandos kubectl.

Este exemplo YAML demonstra o comando apply:

- task: Kubernetes@1
  displayName: kubectl apply using arguments
  inputs:
    connectionType: Azure Resource Manager
    azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
    azureResourceGroup: $(azureResourceGroup)
    kubernetesCluster: $(kubernetesCluster)
    command: apply
    arguments: -f mhc-aks.yaml

Este exemplo YAML demonstra o uso de um arquivo de configuração com o comando apply:

- task: Kubernetes@1
  displayName: kubectl apply using configFile
  inputs:
    connectionType: Azure Resource Manager
    azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
    azureResourceGroup: $(azureResourceGroup)
    kubernetesCluster: $(kubernetesCluster)
    command: apply
    useConfigurationFile: true
    configuration: mhc-aks.yaml

Este exemplo yaml mostra o uso de como usar o comando scale para diminuir o número de réplicas em uma implantação para 0.

- task: Kubernetes@1
      displayName: 'Scale down deployment $(k8sDeployment) to 0'
      inputs:
        connectionType: 'Kubernetes Service Connection'
        kubernetesServiceEndpoint: $(kubernetesServiceConnection)
        command: 'scale'
        arguments: 'deployment/$(k8sDeployment) --replicas=0'
        namespace: $(namespace)

Segredos

Os objetos kubernetes do tipo segredo destinam-se a conter informações confidenciais, como senhas, tokens OAuth e chaves ssh. Colocar essas informações em segredo é mais seguro e flexível do que colocá-la palavra por palavra em uma definição de pod ou em uma imagem do Docker. O Azure Pipelines simplifica a adição de ImagePullSecrets a uma conta de serviço ou a configuração de qualquer segredo genérico, conforme descrito abaixo.

ImagePullSecret

Este exemplo YAML demonstra a configuração de ImagePullSecrets:

    - task: Kubernetes@1
      displayName: kubectl apply for secretType dockerRegistry
      inputs:
        azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
        azureResourceGroup: $(azureResourceGroup)
        kubernetesCluster: $(kubernetesCluster)
        command: apply
        arguments: -f mhc-aks.yaml
        secretType: dockerRegistry
        containerRegistryType: Azure Container Registry
        azureSubscriptionEndpointForSecrets: $(azureSubscriptionEndpoint)
        azureContainerRegistry: $(azureContainerRegistry)
        secretName: mysecretkey2
        forceUpdate: true

Segredos Genéricos

Este exemplo YAML cria segredos genéricos de valores literais especificados para a entrada secretArguments:

    - task: Kubernetes@1
      displayName: secretType generic with literal values
      inputs:
        azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
        azureResourceGroup: $(azureResourceGroup)
        kubernetesCluster: $(kubernetesCluster)
        command: apply
        arguments: -f mhc-aks.yaml
        secretType: generic
        secretArguments: --from-literal=contoso=5678
        secretName: mysecretkey

As variáveis de pipeline podem ser usadas a fim de transmitir argumentos para especificar valores literais, conforme mostrado aqui:

    - task: Kubernetes@1
      displayName: secretType generic with pipeline variables
      inputs:
        azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
        azureResourceGroup: $(azureResourceGroup)
        kubernetesCluster: $(kubernetesCluster)
        command: apply
        arguments: -f mhc-aks.yaml
        secretType: generic
        secretArguments: --from-literal=contoso=$(contosovalue)
        secretName: mysecretkey

O ConfigMap

O ConfigMaps permite desacoplar artefatos de configuração do conteúdo da imagem para manter a portabilidade de aplicativos em contêineres.

Este exemplo YAML cria um ConfigMap apontando para um arquivo ConfigMap:

    - task: Kubernetes@1
      displayName: kubectl apply
      inputs:
        configMapName: myconfig
        useConfigMapFile: true
        configMapFile: src/configmap

Este exemplo YAML cria um ConfigMap especificando os valores literais diretamente como a entrada configMapArguments e configurando forceUpdate como true:

    - task: Kubernetes@1
      displayName: configMap with literal values
      inputs:
        azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
        azureResourceGroup: $(azureResourceGroup)
        kubernetesCluster: $(kubernetesCluster)
        command: apply
        arguments: -f mhc-aks.yaml
        secretType: generic
        secretArguments: --from-literal=contoso=$(contosovalue)
        secretName: mysecretkey4
        configMapName: myconfig
        forceUpdateConfigMap: true
        configMapArguments: --from-literal=myname=contoso

Você pode usar variáveis de pipeline para transmitir valores literais ao criar ConfigMap, conforme mostrado aqui:

    - task: Kubernetes@1
      displayName: configMap with pipeline variables
      inputs:
        azureSubscriptionEndpoint: $(azureSubscriptionEndpoint)
        azureResourceGroup: $(azureResourceGroup)
        kubernetesCluster: $(kubernetesCluster)
        command: apply
        arguments: -f mhc-aks.yaml
        secretType: generic
        secretArguments: --from-literal=contoso=$(contosovalue)
        secretName: mysecretkey4
        configMapName: myconfig
        forceUpdateConfigMap: true
        configMapArguments: --from-literal=myname=$(contosovalue)

Solução de problemas

Meu cluster Kubernetes está protegido por um firewall e estou usando agentes hospedados. Como posso implantar nesse cluster?

Você pode conceder acesso de agentes hospedados por meio do firewall, permitindo os endereços IP para os agentes hospedados. Para obter mais detalhes, consulte Intervalos de IP do agente

Requisitos

Requisito	Descrição
Tipos de pipeline	YAML, build clássico, versão clássica
Executa em	Agent, DeploymentGroup
Demandas	Nenhum
Funcionalidades	Essa tarefa não atende a nenhuma demanda para tarefas subsequentes no trabalho.
Restrições de comando	Qualquer
Variáveis configuráveis	Qualquer
Versão do agente	Todas as versões do agente com suporte.
Categoria da tarefa	Implantar