Condividi tramite


KubernetesManifest@1 - Attività Distribuire in Kubernetes v1

Usare i file manifesto di Kubernetes per eseguire la distribuzione in cluster o anche creare il bake dei file manifesto da usare per le distribuzioni usando i grafici Helm.

Sintassi

# Deploy to Kubernetes v1
# Use Kubernetes manifest files to deploy to clusters or even bake the manifest files to be used for deployments using Helm charts.
- task: KubernetesManifest@1
  inputs:
    #action: 'deploy' # 'bake' | 'createSecret' | 'delete' | 'deploy' | 'patch' | 'promote' | 'scale' | 'reject'. Action. Default: deploy.
    #connectionType: 'kubernetesServiceConnection' # 'azureResourceManager' | 'kubernetesServiceConnection'. Required when action != bake. Service connection type. Default: kubernetesServiceConnection.
    #kubernetesServiceConnection: # string. Alias: kubernetesServiceEndpoint. Required when action != bake && connectionType = kubernetesServiceConnection. Kubernetes service connection. 
    #azureSubscriptionConnection: # string. Alias: azureSubscriptionEndpoint. Required when action != bake && connectionType = azureResourceManager. Azure subscription. 
    #azureResourceGroup: # string. Required when action != bake && connectionType = azureResourceManager. Resource group. 
    #kubernetesCluster: # string. Required when action != bake && connectionType = azureResourceManager. Kubernetes cluster. 
    #useClusterAdmin: false # boolean. Optional. Use when connectionType = azureResourceManager. Use cluster admin credentials. Default: false.
    #namespace: # string. Namespace. 
    #strategy: 'none' # 'canary' | 'none'. Optional. Use when action = deploy || action = promote || action = reject. Strategy. Default: none.
    #trafficSplitMethod: 'pod' # 'pod' | 'smi'. Optional. Use when strategy = canary. Traffic split method. Default: pod.
    #percentage: '0' # string. Required when strategy = Canary && action = deploy. Percentage. Default: 0.
    #baselineAndCanaryReplicas: '1' # string. Required when strategy = Canary && action = deploy && trafficSplitMethod = SMI. Baseline and canary replicas. Default: 1.
    #manifests: # string. Required when action = deploy || action = promote || action = reject. Manifests. 
    #containers: # string. Optional. Use when action = deploy || action = promote || action = bake. Containers. 
    #imagePullSecrets: # string. Optional. Use when action = deploy || action = promote. ImagePullSecrets. 
    #renderType: 'helm' # 'helm' | 'kompose' | 'kustomize'. Optional. Use when action = bake. Render Engine. Default: helm.
    #dockerComposeFile: # string. Required when action = bake && renderType = kompose. Path to docker compose file. 
    #helmChart: # string. Required when action = bake && renderType = helm. Helm Chart. 
    #releaseName: # string. Optional. Use when action = bake && renderType = helm. Helm Release Name. 
    #overrideFiles: # string. Optional. Use when action = bake && renderType = helm. Override Files. 
    #overrides: # string. Optional. Use when action = bake && renderType = helm. Overrides. 
    #kustomizationPath: # string. Optional. Use when action = bake && renderType = kustomize. Kustomization Path. 
    #resourceToPatch: 'file' # 'file' | 'name'. Required when action = patch. Resource to patch. Default: file.
    #resourceFileToPatch: # string. Required when action = patch && resourceToPatch = file. File path. 
    #kind: # 'deployment' | 'replicaset' | 'statefulset'. Required when action = scale || resourceToPatch = name. Kind. 
    #name: # string. Required when action = scale || resourceToPatch = name. Name. 
    #replicas: # string. Required when action = scale. Replica count. 
    #mergeStrategy: 'strategic' # 'json' | 'merge' | 'strategic'. Required when action = patch. Merge Strategy. Default: strategic.
    #arguments: # string. Optional. Use when action = delete. Arguments. 
    #patch: # string. Required when action = patch. Patch. 
    #secretType: 'dockerRegistry' # 'dockerRegistry' | 'generic'. Required when action = createSecret. Type of secret. Default: dockerRegistry.
    #secretName: # string. Optional. Use when action = createSecret. Secret name. 
    #secretArguments: # string. Optional. Use when action = createSecret && secretType = generic. Arguments. 
    #dockerRegistryEndpoint: # string. Optional. Use when action = createSecret && secretType = dockerRegistry. Docker registry service connection. 
    #rolloutStatusTimeout: '0' # string. Optional. Use when action = deploy || action = patch || action = scale || action = promote. Timeout for rollout status. Default: 0.
    #resourceType: 'Microsoft.ContainerService/managedClusters' # string. Optional. Use when action = deploy. Resource type. Default: Microsoft.ContainerService/managedClusters.
# Deploy to Kubernetes v1
# Use Kubernetes manifest files to deploy to clusters or even bake the manifest files to be used for deployments using Helm charts.
- task: KubernetesManifest@1
  inputs:
    #action: 'deploy' # 'bake' | 'createSecret' | 'delete' | 'deploy' | 'patch' | 'promote' | 'scale' | 'reject'. Action. Default: deploy.
    #connectionType: 'kubernetesServiceConnection' # 'azureResourceManager' | 'kubernetesServiceConnection'. Required when action != bake. Service connection type. Default: kubernetesServiceConnection.
    #kubernetesServiceConnection: # string. Alias: kubernetesServiceEndpoint. Required when action != bake && connectionType = kubernetesServiceConnection. Kubernetes service connection. 
    #azureSubscriptionConnection: # string. Alias: azureSubscriptionEndpoint. Required when action != bake && connectionType = azureResourceManager. Azure subscription. 
    #azureResourceGroup: # string. Required when action != bake && connectionType = azureResourceManager. Resource group. 
    #kubernetesCluster: # string. Required when action != bake && connectionType = azureResourceManager. Kubernetes cluster. 
    #useClusterAdmin: false # boolean. Optional. Use when connectionType = azureResourceManager. Use cluster admin credentials. Default: false.
    #namespace: # string. Namespace. 
    #strategy: 'none' # 'canary' | 'none'. Optional. Use when action = deploy || action = promote || action = reject. Strategy. Default: none.
    #trafficSplitMethod: 'pod' # 'pod' | 'smi'. Optional. Use when strategy = canary. Traffic split method. Default: pod.
    #percentage: '0' # string. Required when strategy = Canary && action = deploy. Percentage. Default: 0.
    #baselineAndCanaryReplicas: '1' # string. Required when strategy = Canary && action = deploy && trafficSplitMethod = SMI. Baseline and canary replicas. Default: 1.
    #manifests: # string. Required when action = deploy || action = promote || action = reject. Manifests. 
    #containers: # string. Optional. Use when action = deploy || action = promote || action = bake. Containers. 
    #imagePullSecrets: # string. Optional. Use when action = deploy || action = promote. ImagePullSecrets. 
    #renderType: 'helm' # 'helm' | 'kompose' | 'kustomize'. Optional. Use when action = bake. Render Engine. Default: helm.
    #dockerComposeFile: # string. Required when action = bake && renderType = kompose. Path to docker compose file. 
    #helmChart: # string. Required when action = bake && renderType = helm. Helm Chart. 
    #releaseName: # string. Optional. Use when action = bake && renderType = helm. Helm Release Name. 
    #overrideFiles: # string. Optional. Use when action = bake && renderType = helm. Override Files. 
    #overrides: # string. Optional. Use when action = bake && renderType = helm. Overrides. 
    #kustomizationPath: # string. Optional. Use when action = bake && renderType = kustomize. Kustomization Path. 
    #resourceToPatch: 'file' # 'file' | 'name'. Required when action = patch. Resource to patch. Default: file.
    #resourceFileToPatch: # string. Required when action = patch && resourceToPatch = file. File path. 
    #kind: # 'deployment' | 'replicaset' | 'statefulset'. Required when action = scale || resourceToPatch = name. Kind. 
    #name: # string. Required when action = scale || resourceToPatch = name. Name. 
    #replicas: # string. Required when action = scale. Replica count. 
    #mergeStrategy: 'strategic' # 'json' | 'merge' | 'strategic'. Required when action = patch. Merge Strategy. Default: strategic.
    #arguments: # string. Optional. Use when action = delete. Arguments. 
    #patch: # string. Required when action = patch. Patch. 
    #secretType: 'dockerRegistry' # 'dockerRegistry' | 'generic'. Required when action = createSecret. Type of secret. Default: dockerRegistry.
    #secretName: # string. Optional. Use when action = createSecret. Secret name. 
    #secretArguments: # string. Optional. Use when action = createSecret && secretType = generic. Arguments. 
    #dockerRegistryEndpoint: # string. Optional. Use when action = createSecret && secretType = dockerRegistry. Docker registry service connection. 
    #rolloutStatusTimeout: '0' # string. Optional. Use when action = deploy || action = patch || action = scale || action = promote. Timeout for rollout status. Default: 0.

Ingressi dati

action - 'azione
string. Valori consentiti: bake, createSecret (crea segreto), delete, , patchdeploy, promote, scale, , reject. Valore predefinito: deploy

Specifica l'azione da eseguire.


connectionType - tipo di connessione del servizio
string. Obbligatorio quando action != bake. Valori consentiti: azureResourceManager (Azure Resource Manager), kubernetesServiceConnection (Connessione al servizio Kubernetes). Valore predefinito: kubernetesServiceConnection

Selezionare un tipo di connessione al servizio Kubernetes.

  • kubernetesServiceConnection (Connessione al servizio Kubernetes): consente di fornire un file KubeConfig, specificare un account del servizio o importare un'istanza del servizio Azure Kubernetes con l'opzione Sottoscrizione di Azure . L'importazione di un'istanza del servizio Azure Kubernetes con l'opzione sottoscrizione di Azure richiede l'accesso al cluster Kubernetes al momento della configurazione della connessione del servizio.
  • azureResourceManager (Azure Resource Manager): consente di selezionare un'istanza del servizio Azure Kubernetes. Non accede al cluster Kubernetes in fase di configurazione della connessione al servizio.

Per altre informazioni, vedere Note.


kubernetesServiceConnection - connessione al servizio Kubernetes
Alias di input: kubernetesServiceEndpoint. string. Obbligatorio quando action != bake && connectionType = kubernetesServiceConnection.

Specifica una connessione al servizio Kubernetes.


azureSubscriptionConnection - sottoscrizione di Azure
Alias di input: azureSubscriptionEndpoint. string. Obbligatorio quando action != bake && connectionType = azureResourceManager.

Selezionare la sottoscrizione di Azure Resource Manager, che contiene Registro Azure Container.Nota: per configurare la nuova connessione al servizio, selezionare la sottoscrizione di Azure dall'elenco e fare clic su "Autorizza". Se la sottoscrizione non è elencata o se si vuole usare un'entità servizio esistente, è possibile configurare una connessione al servizio Azure usando il pulsante "Aggiungi" o "Gestisci".


azureResourceGroup - Gruppo di risorse
string. Obbligatorio quando action != bake && connectionType = azureResourceManager.

Selezionare un gruppo di risorse di Azure.


kubernetesCluster - cluster Kubernetes
string. Obbligatorio quando action != bake && connectionType = azureResourceManager.

Selezionare un cluster gestito di Azure.


useClusterAdmin - Usare le credenziali di amministratore del cluster
boolean. Opzionale. Usare quando connectionType = azureResourceManager. Valore predefinito: false

Usare le credenziali di amministratore del cluster anziché le credenziali utente del cluster predefinite.


namespace - spazio dei nomi
string.

Specifica lo spazio dei nomi per i comandi utilizzando il –namespace flag. Se lo spazio dei nomi non viene specificato, i comandi verranno eseguiti nello spazio dei nomi predefinito.


strategy - Strategia
string. Opzionale. Usare quando action = deploy || action = promote || action = reject. Valori consentiti: canary, none. Valore predefinito: none

Specifica la strategia di distribuzione utilizzata nell'azione prima di un'azione o reject di un'azione.deploypromote Attualmente, canary è l'unica strategia di distribuzione accettabile.


trafficSplitMethod - Metodo di suddivisione del traffico
string. Opzionale. Usare quando strategy = canary. Valori consentiti: pod, smi. Valore predefinito: pod

Per il valore smi, la suddivisione percentuale del traffico viene eseguita a livello di richiesta utilizzando una mesh di servizi. Una service mesh deve essere configurata da un amministratore del cluster. Questa attività gestisce l'orchestrazione degli oggetti SMI TrafficSplit .

Per il valore pod, la suddivisione percentuale non è possibile a livello di richiesta in assenza di una mesh di servizi. Al contrario, l'input percentuale viene utilizzato per calcolare le repliche per la baseline e il canary. Il calcolo è una percentuale di repliche specificate nei manifesti di input per la variante stabile.


percentage - Percentuale
string. Obbligatorio quando strategy = Canary && action = deploy. Valore predefinito: 0

Percentuale utilizzata per calcolare il numero di repliche di varianti di base e varianti canary dei carichi di lavoro contenuti nei file manifesto.

Per l'input percentuale specificato, calcolare:

(percentuale × numero di repliche) / 100

Se il risultato non è un numero intero, il floor matematico del risultato viene utilizzato quando vengono create le varianti baseline e canary.

Si supponga, ad esempio, che la distribuzione hello-world si trovi nel file manifesto di input e che le righe seguenti si trovino nell'input dell'attività:

replicas: 4
strategy: canary
percentage: 25

In questo caso, le hello-world-baseline distribuzioni e hello-world-canary vengono create con una replica ciascuna. La variante di base viene creata con la stessa immagine e lo stesso tag della versione stabile, ovvero la variante a quattro repliche prima della distribuzione. La variante canary viene creata con l'immagine e il tag corrispondenti alle modifiche appena implementate.


baselineAndCanaryReplicas - Repliche di base e canary
string. Obbligatorio quando strategy = Canary && action = deploy && trafficSplitMethod = SMI. Valore predefinito: 1

Quando si imposta trafficSplitMethod su smi, la percentuale di suddivisione del traffico viene controllata nel piano della mesh del servizio. È possibile controllare il numero effettivo di repliche per le varianti canary e baseline indipendentemente dalla suddivisione del traffico.

Si supponga, ad esempio, che il manifesto di distribuzione dell'input specifichi 30 repliche per la variante stabile. Si supponga inoltre di specificare l'input seguente per l'attività:

strategy: canary
trafficSplitMethod: smi
percentage: 20
baselineAndCanaryReplicas: 1

In questo caso, la variante stabile riceve l'80% del traffico, mentre le varianti di base e canary ricevono ciascuna la metà dei 20%specificati. Le varianti di base e canary non ricevono tre repliche ciascuna. Ricevono invece il numero specificato di repliche, il che significa che ognuna di esse riceve una replica.


manifests - Manifesti
string. Obbligatorio quando action = deploy || action = promote || action = reject.

Specifica il percorso dei file manifesto da utilizzare per la distribuzione. Ogni riga rappresenta un singolo percorso. Un modello di corrispondenza dei file è un valore accettabile per ogni riga.


containers - Contenitori
string. Opzionale. Usare quando action = deploy || action = promote || action = bake.

Specifica l'URL completo della risorsa dell'immagine da utilizzare per le sostituzioni nei file manifesto. L'URL contosodemo.azurecr.io/helloworld:test è un esempio.


imagePullSecrets - ImagePullSecrets
string. Opzionale. Usare quando action = deploy || action = promote.

Specifica un input multilinea in cui ogni riga contiene il nome di un segreto del Registro di sistema Docker che è già stato configurato all'interno del cluster. Ogni nome segreto viene aggiunto per imagePullSecrets i carichi di lavoro presenti nei file manifesto di input.


renderType - Motore di rendering
string. Opzionale. Usare quando action = bake. Valori consentiti: helm, kompose, kustomize. Valore predefinito: helm

Specifica il tipo di rendering utilizzato per produrre i file manifesto.


dockerComposeFile - Percorso del file docker compose
string. Obbligatorio quando action = bake && renderType = kompose.

Specifica un percorso di file docker-compose.


helmChart - Mappa del timone
string. Obbligatorio quando action = bake && renderType = helm.

Specifica il percorso del grafico Helm da fissare.


releaseName - Nome della versione Helm
string. Opzionale. Usare quando action = bake && renderType = helm.

Specifica il nome della versione Helm da usare.


overrideFiles - Sovrascrivi i file
string. Opzionale. Usare quando action = bake && renderType = helm.

Specifica un input multilinea che accetta il percorso dei file di sostituzione. I file vengono usati quando vengono inseriti i file manifesto dai grafici Helm.


overrides - Esegue l' override
string. Opzionale. Usare quando action = bake && renderType = helm.

Specifica i valori di sostituzione da impostare.


kustomizationPath - Percorso di kustomizzazione
string. Opzionale. Usare quando action = bake && renderType = kustomize.

Specifica l'argomento che deve essere il percorso della directory contenente il file o un URL del repository Git con un suffisso di percorso che specifica same rispetto alla radice del repository.


resourceToPatch - Risorsa da applicare alla patch
string. Obbligatorio quando action = patch. Valori consentiti: file, name. Valore predefinito: file

Indica uno dei seguenti metodi di patch:

  • Un file manifesto identifica gli oggetti a cui applicare la patch.
  • Un singolo oggetto viene identificato dal tipo e dal nome come destinazione della patch.

I valori accettabili sono file e nome.


resourceFileToPatch - percorso file
string. Obbligatorio quando action = patch && resourceToPatch = file.

Specifica il percorso del file utilizzato per una patch.


kind - Gentile
string. Obbligatorio quando action = scale || resourceToPatch = name. Valori consentiti: deployment, replicaset, statefulset.

Specifica il tipo di oggetto K8s, ad esempio deployment, replicaSet e altro ancora.


name - Nome
string. Obbligatorio quando action = scale || resourceToPatch = name.

Specifica il nome dell'oggetto K8s.


replicas - Numero di repliche
string. Obbligatorio quando action = scale.

Specifica il numero di repliche a cui ridimensionare.


replicas - Numero di repliche
string. Obbligatorio quando action = scale.

Specifica il nome dell'oggetto K8s.


mergeStrategy - Strategia di fusione
string. Obbligatorio quando action = patch. Valori consentiti: json, merge, strategic. Valore predefinito: strategic

Specifica il tipo di patch fornita.


arguments - argomenti
string. Opzionale. Usare quando action = delete.

Specifica gli argomenti del kubectl delete comando. Un esempio è: arguments: deployment hello-world foo-bar


patch - patch
string. Obbligatorio quando action = patch.

Specifica il contenuto della patch.


secretType - Tipo di segreto
string. Obbligatorio quando action = createSecret. Valori consentiti: dockerRegistry, generic. Valore predefinito: dockerRegistry

Crea o aggiorna un imagepullsecretgenerico o docker . Specificare dockerRegistry per creare o aggiornare il imagepullsecret del Registro di sistema selezionato. Un imagePullSecret è un modo per passare un segreto che contiene una password del registro contenitori a Kubelet, in modo che possa eseguire il pull di un'immagine privata per conto del pod.


secretName - nome segreto
string. Opzionale. Usare quando action = createSecret.

Specifica il nome del segreto. È possibile usare questo nome segreto nel file di configurazione YAML di Kubernetes.


secretArguments - argomenti
string. Opzionale. Usare quando action = createSecret && secretType = generic.

Specifica le chiavi e i valori letterali da inserire nel segreto. Ad esempio, --from-literal=key1=value1--from-literal=key2="top secret".


dockerRegistryEndpoint - connessione al servizio del Registro di sistema Docker
string. Opzionale. Usare quando action = createSecret && secretType = dockerRegistry.

Specifica le credenziali della connessione al servizio specificata che vengono utilizzate per creare un segreto del Registro di sistema Docker all'interno del cluster. I file manifesto sotto il imagePullSecrets campo possono quindi fare riferimento al nome di questo segreto.


rolloutStatusTimeout - Timeout per lo stato di rollout
string. Opzionale. Usare quando action = deploy || action = patch || action = scale || action = promote. Valore predefinito: 0

Specifica il periodo di tempo (in secondi) di attesa prima di terminare watch on rollout lo stato.


resourceType - Tipo di risorsa
string. Opzionale. Usare quando action = deploy. Valore predefinito: Microsoft.ContainerService/managedClusters

Il tipo di risorsa (parco istanze, cluster gestito).


Opzioni di controllo delle attività

Tutte le attività dispongono di opzioni di controllo oltre ai relativi input attività. Per altre informazioni, vedere Opzioni di controllo e proprietà comuni delle attività.

Variabili di uscita

Questa attività definisce le variabili di output seguenti , che è possibile utilizzare nei passaggi downstream, nei processi e nelle fasi.

manifestsBundle
La posizione dei bundle manifest creati dall'azione bake

Osservazioni:

Considerazioni sulla connessione al servizio Kubernetes durante l'accesso al servizio Azure Kubernetes

È possibile creare una connessione al servizio Kubernetes con una delle opzioni seguenti.

  • KubeConfig
  • Account di servizio
  • Sottoscrizione di Azure

Screenshot della scelta di un metodo di autenticazione della connessione al servizio Kubernetes.

Quando si seleziona l'opzione sottoscrizione di Azure, Kubernetes deve essere accessibile ad Azure DevOps in fase di configurazione della connessione al servizio. È possibile che non sia possibile creare una connessione al servizio, ad esempio creato un cluster privato o che il cluster abbia account locali disabilitati. In questi casi, Azure DevOps non riesce a connettersi al cluster in fase di configurazione della connessione al servizio e viene visualizzato un blocco schermata Caricamento di spazi dei nomi.

Screenshot della scelta di una finestra di dialogo di autenticazione della connessione al servizio Kubernetes bloccata durante il caricamento degli spazi dei nomi.

A partire da Kubernetes 1.24, i token di lunga durata non vengono più creati per impostazione predefinita . Kubernetes consiglia di non usare token di lunga durata. Di conseguenza, le attività che usano una connessione al servizio Kubernetes creata con l'opzione sottoscrizione di Azure non hanno accesso al token permanente necessario per l'autenticazione e non possono accedere al cluster Kubernetes. In questo modo viene visualizzata anche la finestra di dialogo caricamento degli spazi dei nomi bloccata.

Usare la connessione al servizio Azure Resource Manager per accedere al servizio Azure Kubernetes

Per i clienti del servizio Azure Kubernetes, il tipo di connessione del servizio Azure Resource Manager offre il metodo migliore per connettersi a un cluster privato o a un cluster con account locali disabilitati. Questo metodo non dipende dalla connettività del cluster al momento della creazione di una connessione al servizio. L'accesso al servizio Azure Kubernetes viene posticipato al runtime della pipeline, con i vantaggi seguenti:

  • L'accesso a un cluster del servizio Azure Kubernetes (privato) può essere eseguito da un agente del set di scalabilità o self-hosted con visibilità al cluster.
  • Viene creato un token per ogni attività che usa una connessione al servizio Azure Resource Manager. In questo modo si garantisce la connessione a Kubernetes con un token di breve durata, ovvero la raccomandazione Kubernetes.
  • È possibile accedere al servizio Azure Kubernetes anche quando gli account locali sono disabilitati.

Domande frequenti sulla connessione al servizio

Viene visualizzato il messaggio di errore seguente: Impossibile trovare alcun segreto associato all'account del servizio. Cosa sta succedendo?

Si usa l'opzione Connessione al servizio Kubernetes con sottoscrizione di Azure. Questo metodo viene aggiornato per creare token di lunga durata. Questo dovrebbe essere disponibile a metà maggio. È tuttavia consigliabile iniziare a usare il tipo di connessione del servizio di Azure e non usare token di lunga durata in base alle indicazioni di Kubernetes .

Si usa il servizio Azure Kubernetes e non si vuole modificare nulla, è possibile continuare a usare le attività con la connessione al servizio Kubernetes?

Questo metodo viene aggiornato per creare token di lunga durata. Questo dovrebbe essere disponibile a metà maggio. Tuttavia, tenere presente che questo approccio è basato su linee guida di Kubernetes.

Si usano le attività kubernetes e la connessione al servizio Kubernetes, ma non il servizio Azure Kubernetes. Dovrei essere preoccupato?

Le attività continueranno a funzionare come prima.

Il tipo di connessione del servizio Kubernetes verrà rimosso?

Le attività kubernetes funzionano con qualsiasi cluster Kubernetes, indipendentemente dalla posizione in cui sono in esecuzione. La connessione al servizio Kubernetes continuerà a esistere.

Sono un cliente del servizio Azure Kubernetes e tutto funziona correttamente, devo agire?

Non c'è bisogno di cambiare nulla. Se si usa la connessione al servizio Kubernetes e la sottoscrizione di Azure selezionata durante la creazione, è necessario tenere presente le indicazioni su Kubernetes sull'uso di token di lunga durata.

Si sta creando un ambiente Kubernetes e non è possibile usare le connessioni al servizio

Se non è possibile accedere al servizio Azure Kubernetes durante la creazione dell'ambiente, è possibile usare un ambiente vuoto e impostare l'input connectionType su una connessione al servizio Azure Resource Manager.

Il servizio Azure Kubernetes è configurato con il controllo degli accessi in base al ruolo di Azure Active Directory e la pipeline non funziona. Questi aggiornamenti verranno risolti?

L'accesso a Kubernetes quando il controllo degli accessi in base al ruolo di AAD è abilitato non è correlato alla creazione di token. Per evitare un prompt interattivo, verrà supportato kubelogin in un aggiornamento futuro.

Usare un'attività manifesto Kubernetes in una pipeline di compilazione o versione per creare e distribuire manifesti nei cluster Kubernetes.

Questa attività supporta quanto segue:

  • Sostituzione artefatto: l'azione di distribuzione accetta come input un elenco di immagini del contenitore che è possibile specificare insieme ai relativi tag e digest. Lo stesso input viene sostituito nei file manifesto non templatizzati prima dell'applicazione al cluster. Questa sostituzione garantisce che i nodi del cluster eseguano il pull della versione corretta dell'immagine.

  • Stabilità del manifesto: viene controllato lo stato di implementazione degli oggetti Kubernetes distribuiti. I controlli di stabilità vengono incorporati per determinare se lo stato dell'attività è un esito positivo o negativo.

  • Annotazioni di tracciabilità: le annotazioni vengono aggiunte agli oggetti Kubernetes distribuiti per sovrapporre le informazioni di tracciabilità. Sono supportate le annotazioni seguenti:

    • azure-pipelines/org
    • azure-pipelines/progetto
    • azure-pipelines/pipeline
    • azure-pipelines/pipelineId
    • azure-pipelines/execution
    • azure-pipelines/executionuri
    • azure-pipelines/jobName
  • Gestione dei segreti: l'azione createSecret consente di creare i segreti del Registro di sistema Docker utilizzando le connessioni al servizio del Registro di sistema Docker. Consente inoltre di creare segreti generici utilizzando variabili di testo normale o variabili segrete. Prima della distribuzione nel cluster, è possibile utilizzare l'input secrets insieme all'azione deploy per aumentare i file manifesto di input con il valore appropriato imagePullSecrets .

  • Bake manifest: l'azione bake dell'attività consente di inserire modelli nei file manifesto di Kubernetes. L'azione utilizza strumenti come Helm, Componi e Kustomize. Con il baking, questi file manifesto Kubernetes sono utilizzabili per le distribuzioni nel cluster.

  • Strategia di distribuzione: la scelta della canary strategia con l'azione deploy comporta la creazione di nomi del carico di lavoro con suffisso -baseline e -canary. L'attività supporta due metodi di suddivisione del traffico:

    • Interfaccia Service Mesh: l'astrazione SMI ( Service Mesh Interface ) consente la configurazione con provider di service mesh come Linkerd e Istio. L'attività Manifesto Kubernetes esegue il mapping degli oggetti SMI TrafficSplit ai servizi stable, baseline e canary durante il ciclo di vita della strategia di distribuzione.

      Le distribuzioni Canary basate su una mesh di servizi e che utilizzano questa attività sono più accurate. Questa precisione è dovuta al modo in cui i fornitori di service mesh abilitano la suddivisione granulare del traffico basata sulla percentuale. La mesh del servizio utilizza il registro dei servizi e i contenitori sidecar inseriti nei pod. Questa iniezione si verifica insieme ai contenitori dell'applicazione per ottenere la suddivisione granulare del traffico.

    • Kubernetes senza service mesh: in assenza di una service mesh, è possibile che non si ottenga l'esatta suddivisione percentuale desiderata a livello di richiesta. Tuttavia, è possibile eseguire distribuzioni canary utilizzando le varianti di base e canary accanto alla variante stabile.

      Il servizio invia richieste ai pod di tutte e tre le varianti del carico di lavoro man mano che vengono soddisfatti i vincoli dell'etichetta del selettore. Kubernetes Manifest rispetta queste richieste durante la creazione di varianti di base e canary. Questo comportamento di routing consente di ottenere l'effetto desiderato di instradare solo una parte delle richieste totali al canary.

    Confrontare i carichi di lavoro di base e canary usando un'attività di intervento manuale nelle pipeline di versione o un'attività di ritardo nelle pipeline YAML. Eseguire il confronto prima di utilizzare l'azione di promozione o rifiuto dell'attività.

Azione di distribuzione

Il codice YAML seguente è un esempio di distribuzione in uno spazio dei nomi Kubernetes usando i file manifesto:

steps:
- task: KubernetesManifest@0
  displayName: Deploy
  inputs:
    kubernetesServiceConnection: someK8sSC1
    namespace: default
    manifests: |
      manifests/deployment.yml
      manifests/service.yml
    containers: |
      foo/demo:$(tagVariable1)
      bar/demo:$(tagVariable2)
    imagePullSecrets: |
      some-secret
      some-other-secret

Nell'esempio precedente, l'attività tenta di trovare corrispondenze per le immagini foo/demo e bar/demo nei campi immagine dei file manifesto. Per ogni corrispondenza trovata, il valore di o tagVariable1tagVariable2 viene aggiunto come tag al nome dell'immagine. È anche possibile specificare i digest nell'input dei contenitori per la sostituzione degli artefatti.

Annotazioni

Sebbene sia possibile creare deploy, promotee reject azioni con input YAML correlati alla strategia di distribuzione, il supporto per un'attività di intervento manuale non è attualmente disponibile per le pipeline di compilazione.

Per le pipeline di versione, è consigliabile usare le azioni e gli input correlati alla strategia di distribuzione nella sequenza seguente:

  1. Un'azione di distribuzione specificata con strategy: canary e percentage: $(someValue).
  2. Un'attività di intervento manuale in modo da poter sospendere la pipeline e confrontare la variante di base con la variante canary.
  3. Un'azione di promozione che viene eseguita se un'attività di intervento manuale viene ripresa e un'azione di rifiuto che viene eseguita se un'attività di intervento manuale viene rifiutata.

Crea azione segreta

Il codice YAML seguente mostra un esempio di creazione di segreti del Registro di sistema Docker usando la connessione al servizio Registro di sistema Docker:

steps:
- task: KubernetesManifest@0
  displayName: Create secret
  inputs: 
    action: createSecret
    secretType: dockerRegistry
    secretName: foobar
    dockerRegistryEndpoint: demoACR
    kubernetesServiceConnection: someK8sSC
    namespace: default

Questo codice YAML mostra un esempio di creazione di segreti generici:

steps:
- task: KubernetesManifest@0
  displayName: Create secret
  inputs: 
    action: createSecret
    secretType: generic
    secretName: some-secret
    secretArguments: --from-literal=key1=value1
    kubernetesServiceConnection: someK8sSC
    namespace: default

Azione di cottura

Il codice YAML seguente è un esempio di creazione di file manifesto dai grafici Helm. Si noti l'utilizzo di un input di nome nella prima attività. A questo nome viene fatto riferimento in un secondo momento dal passaggio di distribuzione per specificare il percorso dei manifesti prodotti dal passaggio di bake.

steps:
- task: KubernetesManifest@0
  name: bake
  displayName: Bake K8s manifests from Helm chart
  inputs:
    action: bake
    helmChart: charts/sample
    overrides: 'image.repository:nginx'

- task: KubernetesManifest@0
  displayName: Deploy K8s manifests
  inputs:
    kubernetesServiceConnection: someK8sSC
    namespace: default
    manifests: $(bake.manifestsBundle)
    containers: |
      nginx: 1.7.9

Annotazioni

Per usare Helm direttamente per la gestione dei rilasci e dei rollback, vedere l'attività Creare pacchetti e distribuire i grafici Helm.

Esempio di Kustomizzare

Il codice YAML seguente è un esempio di file manifesto di cottura generati con Kustomize che contengono un kustomization.yaml file.

steps:
- task: KubernetesManifest@0
  name: bake
  displayName: Bake K8s manifests from kustomization path
  inputs:
    action: bake
    renderType: kustomize
    kustomizationPath: folderContainingKustomizationFile

- task: KubernetesManifest@0
  displayName: Deploy K8s manifests
  inputs:
    kubernetesServiceConnection: k8sSC1
    manifests: $(bake.manifestsBundle)

Esempio di Kompose

Il seguente codice YAML è un esempio di cottura di file manifest generati con Kompose, uno strumento di conversione per Docker Compose.

steps:
- task: KubernetesManifest@0
  name: bake
  displayName: Bake K8s manifests from Docker Compose
  inputs:
    action: bake
    renderType: kompose
    dockerComposeFile: docker-compose.yaml

- task: KubernetesManifest@0
  displayName: Deploy K8s manifests
  inputs:
    kubernetesServiceConnection: k8sSC1
    manifests: $(bake.manifestsBundle)

Azione di scalabilità

Il codice YAML seguente mostra un esempio di ridimensionamento degli oggetti:

steps:
- task: KubernetesManifest@0
  displayName: Scale
  inputs: 
    action: scale
    kind: deployment
    name: bootcamp-demo
    replicas: 5
    kubernetesServiceConnection: someK8sSC
    namespace: default

Azione patch

Il codice YAML seguente mostra un esempio di applicazione di patch agli oggetti:

steps:
- task: KubernetesManifest@0
  displayName: Patch
  inputs: 
    action: patch
    kind: pod
    name: demo-5fbc4d6cd9-pgxn4
    mergeStrategy: strategic
    patch: '{"spec":{"containers":[{"name":"demo","image":"foobar/demo:2239"}]}}'
    kubernetesServiceConnection: someK8sSC
    namespace: default

Azione di eliminazione

Questo codice YAML mostra un esempio di eliminazione di oggetti:

steps:
- task: KubernetesManifest@0
  displayName: Delete
  inputs:
    action: delete
    arguments: deployment expressapp
    kubernetesServiceConnection: someK8sSC
    namespace: default

Risoluzione dei problemi

Il cluster Kubernetes si trova dietro un firewall e si stanno usando gli agenti ospitati. Come si esegue la distribuzione in questo cluster?

È possibile concedere l'accesso agli agenti ospitati tramite il firewall, consentendo gli indirizzi IP per gli agenti ospitati. Per altre informazioni dettagliate, vedere Intervalli IP dell'agente.

Come funzionano le richieste alle route dei servizi stabili e varianti con distribuzioni canary?

La relazione del selettore etichette tra pod e servizi in Kubernetes consente di configurare le distribuzioni in modo che un singolo servizio esegua il route delle richieste alle varianti sia stabili che canary. L'attività manifesto Kubernetes lo usa per le distribuzioni canary.

Se l'attività include gli input di action: deploy e strategy: canary, per ogni carico di lavoro (Deployment, ReplicaSet, Pod, ...) definiti nei file manifest di input, vengono creati a -baseline e -canary variante della distribuzione. In questo esempio è presente una distribuzione sampleapp nel file manifesto di input e dopo il completamento dell'esecuzione numero 22 della pipeline, la variante stabile di questa distribuzione denominata sampleapp viene distribuita nel cluster. Nell'esecuzione successiva (in questo caso l'esecuzione numero 23), l'attività manifesto Kubernetes con action: deploy e strategy: canary comporterebbe la creazione di distribuzioni sampleapp-baseline e sampleapp-canary il cui numero di repliche è determinato dal prodotto dell'input dell'attività percentage con il valore del numero desiderato di repliche per la variante stabile finale di sampleapp come per i file manifesto di input.

Escludendo il numero di repliche, la versione di base ha la stessa configurazione della variante stabile, mentre la versione canary ha le nuove modifiche introdotte dall'esecuzione corrente (in questo caso, l'esecuzione numero 23). Se viene impostato un intervento manuale nella pipeline dopo il passaggio sopra indicato, si avrebbe l'opportunità di sospendere la pipeline in modo che l'amministratore della pipeline possa valutare le metriche chiave per le versioni di base e canary e prendere la decisione se le modifiche canary sono sicure e sufficientemente buone per un'implementazione completa.

Gliaction: promote input and strategy: canary or action: reject e delle strategy: canary attività del manifesto Kubernetes possono essere usati rispettivamente per promuovere o rifiutare le modifiche canary. Si noti che in entrambi i casi, al termine di questo passaggio, solo la variante stabile dei carichi di lavoro dichiarati nei file manifesto di input rimarrà distribuita nel cluster, mentre le versioni temporanee di base e canary verranno pulite.

Requisiti

Requisito Descrizione
Tipi di pipeline YAML, build classica, versione classica
Viene eseguito in Agente, DeploymentGroup
Richieste Nessuno
Funzionalità Questa attività non soddisfa alcuna richiesta di attività successive nel processo.
restrizioni dei comandi Qualunque
variabili impostabili Qualunque
Versione agente Tutte le versioni dell'agente supportate.
Categoria attività Distribuire