Kubernetes@1 - Tarefa Kubectl v1

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

Sintaxe

# 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.

Insumos

connectionType - Tipo de conexão de serviço
string. Necessá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: Azure Resource Manager ao usar o Serviço Kubernetes do Azure ou a Conexão de Serviço Kubernetes para qualquer outro cluster.

• Kubernetes Service Connection - Permite fornecer um arquivo KubeConfig, especificar uma Conta de Serviço ou importar uma instância do AKS com a opção de Assinatura do Azure. A importação de uma instância do AKS com a opção de 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 AKS. Não acessa o cluster 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 de conexão de serviço na seção Comentários a seguir.

kubernetesServiceEndpoint - de conexão de serviço Kubernetes
string. Necessário quando connectionType = Kubernetes Service Connection && command != logout.

Selecione uma conexão de serviço Kubernetes.

azureSubscriptionEndpoint - de assinatura do Azure
string. Necessário quando connectionType = Azure Resource Manager && command != logout.

Especifica a assinatura do Azure Resource Manager, 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 em Authorize. Se a sua subscrição não estiver listada ou se pretender utilizar uma Entidade de Serviço existente, pode configurar uma ligação de serviço do Azure utilizando os botões Add ou Manage.

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

Selecione um grupo de recursos do Azure.

kubernetesCluster - de cluster do Kubernetes
string. Necessá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 - de comando
string. Valores permitidos: apply, create, delete, exec, expose, 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 o assistente de tarefas, mas você pode especificar outros comandos kubectl como scale. Use a entrada arguments para especificar parâmetros adicionais para o comando kubectl especificado.

useConfigurationFile - Usar de 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 comando kubectl. O script embutido, nome de arquivo, diretório ou 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 comando kubectl. Pode ser um caminho de arquivo ou um script embutido.

configuration - Caminho do arquivo
string. Necessário quando configurationType = configuration.

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

inline - de configuração em linha
string. Necessário quando configurationType = inline.

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

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

Argumentos para o comando kubectl especificado.

secretType - Tipo de secreta
string. Necessário quando command != login && command != logout. Valores permitidos: dockerRegistry, generic. Valor padrão: dockerRegistry.

Crie/atualize um imagepullsecret genérico ou docker. Selecione dockerRegistry para criar/atualizar o imagepullsecret do registro selecionado. Um imagePullSecret é uma maneira de passar um segredo que contém uma senha de registro de contêiner para o Kubelet para que ele possa extrair uma imagem privada em nome do seu 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 registo de contentor
string. Necessário quando secretType = dockerRegistry && command != login && command != logout. Valores permitidos: Azure Container Registry, Container Registry. Valor padrão: Azure Container Registry.

Selecione um tipo de registro Container. A tarefa pode usar os detalhes da Assinatura do Azure para trabalhar com um registro de Contêiner do Azure. Outros registros de contêiner padrão também são suportados.

dockerRegistryEndpoint - de 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 de registro do Docker. Necessário para comandos que precisam ser autenticados com um registro.

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

Especifica a assinatura do Azure Resource Manager, que contém o 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 em Authorize. Se a sua subscrição não estiver listada ou se pretender utilizar uma Entidade de Serviço existente, pode configurar uma ligação de serviço do Azure utilizando os botões Add 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. Necessário para comandos que precisam ser autenticados com um registro.

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

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

forceUpdate - Force atualiza secretas
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.

O ConfigMaps permite dissociar artefatos de configuração do conteúdo da imagem para manter os aplicativos em contêineres portáteis.

forceUpdateConfigMap - Force update configmap
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 de arquivo
boolean. Opcional. Use quando command != login && command != logout. Valor padrão: false.

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

configMapFile - arquivo ConfigMap
string. Necessá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 no 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 Kubernetes.

versionSpec - Especificações da 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 obtida. Exemplos: 1.7.0, 1.x.0, 4.x.0, 6.10.0, >=6.10.0.

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

Sempre verifica on-line a versão mais recente disponível (stable.txt) que satisfaz as especificações da versão. Isso geralmente é falso, a menos que você tenha um cenário específico para sempre obter o mais recente. Isso fará com que ele incorra em custos de download quando potencialmente não for necessário, especialmente com o pool de compilação hospedado.

specifyLocation - Caminho para kubectl
string. Necessário quando versionOrLocation = location.

Especifica o caminho completo para o arquivo kubectl.exe.

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. A lista de valores permitidos fornece algumas opções comuns para facilitar a seleção ao usar o assistente de tarefas, mas você pode especificar outras opções de saída como jsonpath={.items[*].spec['initContainers', 'containers'][*].image}.

Opções de controlo de tarefas

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

Variáveis de saída

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

KubectlOutput
Armazena a saída do comando kubectl.

Comentários

O que há de novo na versão 1.0.

• Adicionada uma nova entrada de tipo de conexão de serviço para facilitar a seleção de clusters do Azure AKS.
• Substituída 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 esta tarefa para implantar, configurar ou atualizar um cluster 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 Kubernetes Service Connection, descritos abaixo.

Azure Resource Manager

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

Este exemplo de 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 Kubernetes

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

Este exemplo de YAML mostra como uma Conexão de Serviço do Kubernetes é usada para se referir ao cluster do 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 Kubernetes com qualquer uma das seguintes opções.

• KubeConfig
• Conta de Serviço
• Subscrição do Azure

Ao selecionar a opção de 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 de 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 presa.

A partir do Kubernetes 1.24, os tokens de vida longa 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 de Assinatura do Azure não têm acesso ao token permanente necessário para autenticar e não podem acessar seu cluster do Kubernetes. Isso também resulta na caixa de diálogo congelada Carregando namespaces.

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

Para clientes 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 a um cluster que tenha 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 tempo de execução do pipeline, que tem as seguintes vantagens:

• O acesso a um cluster AKS (privado) pode ser realizado a partir de um agente auto-hospedado ou de conjunto de escala 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 é o recomendação do Kubernetes.
• O AKS pode ser acessado mesmo quando as contas locais estão desativadas.

Perguntas frequentes sobre conexão de serviço

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

Você está usando a conexão de serviço do Kubernetes com a opção Assinatura do Azure. Estamos atualizando esse método para criar tokens de longa duração. Espera-se que 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, conforme de orientação 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 esteja disponível em meados de maio. No entanto, esteja ciente de que essa abordagem é contrária orientação do Kubernetes.

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

As suas tarefas continuarão a funcionar 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 estejam sendo executadas. A conexão de serviço do Kubernetes continuará a existir.

Sou um cliente AKS e está tudo a correr bem, devo agir?

Não há necessidade de mudar nada. Se você estiver usando a conexão de serviço do Kubernetes e selecionou a Assinatura do Azure durante a criação, deve estar ciente das orientações do Kubernetes sobre o uso de tokens de longa duração.

Estou criando um ambiente Kubernetes e não tenho opção de usar conexões de serviço

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

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

O acesso ao Kubernetes quando o RBAC do AAD está habilitado não está relacionado à criação de tokens. Para evitar um prompt interativo, suportaremos kubelogin em uma atualização futura.

Comandos

A entrada de comando aceita comandos kubectl.

Este exemplo de YAML demonstra a aplicar comando:

- 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 de 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 de 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 secretos destinam-se a armazenar informações confidenciais, como senhas, tokens OAuth e chaves ssh. Colocar essas informações em segredo é mais seguro e flexível do que colocá-las literalmente 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.

ImagemPullSecret

Este exemplo de 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 de YAML cria segredos genéricos a partir de valores literais especificados para o secretArguments entrada:

    - 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 para passar 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

ConfigMap

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

Este exemplo de 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 de YAML cria um ConfigMap especificando os valores literais diretamente como a entrada configMapArguments e definindo 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 passar valores literais ao criar o 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 neste cluster?

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

Requerimentos

Exigência	Descrição
Tipos de pipeline	YAML, Construção clássica, Versão clássica
Funciona em	Agente, DeploymentGroup
Exigências	Nenhum
Capacidades	Esta tarefa não satisfaz quaisquer exigências para tarefas subsequentes no trabalho.
Restrições de comando	Qualquer
Variáveis configuráveis	Qualquer
Versão do agente	Todas as versões de agente suportadas.
Categoria de tarefa	Implantar