Distribuisci carichi di lavoro dalle DevOps pipeline di Azure ai cluster Amazon EKS privati

Trova il GUID dell' DevOps organizzazione di Azure.

Accedi al tuo DevOps account Azure, quindi usa il seguente URL per trovare il GUID dell'organizzazione: https://dev.azure.com/{DevOps_Org_ID}/_apis/projectCollections?api-version=6.0 Nell'URL, sostituiscilo {DevOps_org_ID} con il tuo ID dell'organizzazione Azure. DevOps

Configura un IdP in. Account AWS

Per configurare un provider di identità (IdP) Account AWS per una connessione al servizio Azure, usa i seguenti passaggi:

Per altri dettagli, vedi Come eseguire la federazione AWS da Azure usando DevOps OpenID Connect.

Crea una policy IAM in Account AWS.

Per creare una policy IAM che fornisca le autorizzazioni richieste al ruolo IAM usato dalla DevOps pipeline di Azure, usa i seguenti passaggi:

Crea un ruolo IAM in Account AWS.

Per configurare un ruolo IAM nella Account AWS connessione al servizio Azure, usa i seguenti passaggi:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::{account_id}:oidc-provider/vstoken.dev.azure.com/{OrganizationGUID}"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "vstoken.dev.azure.com/{OrganizationGUID}:aud": "api://AzureADTokenExchange",
          "vstoken.dev.azure.com/{OrganizationGUID}:sub": "sc://{OrganizationName}/{ProjectName}/{ServiceConnectionName}"
        }
      }
    }
  ]
}

Nella politica, fornisci le tue informazioni per i seguenti segnaposto:

Crea una connessione di servizio nell' DevOps account Azure.

Per configurare una connessione al servizio Azure, usa i seguenti passaggi:

Per ulteriori dettagli, consulta Creare una connessione di servizio nella documentazione Microsoft.

Aggiungi il ruolo IAM al file di configurazione di Amazon EKS.

Il ruolo IAM deve disporre delle autorizzazioni necessarie per eseguire le operazioni richieste sul cluster Amazon EKS. Poiché si tratta di un ruolo di pipeline, il ruolo IAM deve essere in grado di gestire quasi tutti i tipi di risorse sul cluster. Pertanto, l'autorizzazione system:masters di gruppo è appropriata per questo ruolo.

Per aggiungere la configurazione richiesta all'aws-auth ConfigMapinterno di Kubernetes, usa il codice seguente:

- groups:
  - system:masters
  rolearn: arn:aws:iam::{account_id}:role/ADO-role
  username: ADO-role

Sostituiscilo {account_id} con il tuo ID. Account AWS

Per ulteriori informazioni, consulta Come funziona Amazon EKS con IAM nella documentazione di Amazon EKS.

Crea un pool di agenti ospitati autonomamente.

Per configurare un pool di agenti ospitati autonomamente nell' DevOps account Azure, usa i seguenti passaggi:

Per ulteriori dettagli, consulta Creare e gestire pool di agenti nella documentazione Microsoft.

Crea un repository Amazon ECR.

Le immagini Docker utilizzate per distribuire l' DevOps agente Azure e l'applicazione di esempio (webapp) sul cluster Amazon EKS privato devono essere archiviate in un repository Amazon ECR. Per creare un repository Amazon ECR, utilizza i seguenti passaggi:

Per ulteriori dettagli, consulta Creazione di un repository privato Amazon ECR per archiviare immagini nella documentazione di Amazon ECR.

Crea un Dockerfile per creare l'agente Azure DevOps .

Crea un Dockerfile per creare l'immagine Docker su cui è installato l'agente Azure. DevOps Archivia il seguente contenuto in un file denominato: Dockerfile

FROM ubuntu:22.04 
ENV TARGETARCH="linux-x64"
RUN apt update && apt upgrade -y && apt install -y curl git jq libicu70 unzip wget

RUN curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
RUN unzip awscliv2.zip
RUN ./aws/install
RUN rm -rf aws awscliv2.zip

RUN curl -sSL https://get.docker.com/ | sh

RUN curl -sL https://aka.ms/InstallAzureCLIDeb | bash
RUN mkdir -p azp 
WORKDIR /azp/

COPY ./start.sh ./ 
RUN chmod +x ./start.sh

RUN useradd -m -d /home/agent agent 
RUN chown -R agent:agent /azp /home/agent
RUN groupadd -f docker 
RUN usermod -aG docker agent
USER agent

ENTRYPOINT [ "./start.sh" ]

Crea script per l' DevOps agente di Azure.

Per creare lo start.sh script, usa i seguenti passaggi:

Crea un'immagine Docker con l'agente Azure. DevOps

Per creare un'immagine Docker per installare l' DevOps agente di Azure, usa il Dockerfile che hai creato in precedenza per creare l'immagine. Nella stessa directory in cui è archiviato il Dockerfile, esegui i seguenti comandi:

aws ecr get-login-password --region region | docker login --username AWS --password-stdin aws_account_id.dkr.ecr.region.amazonaws.com

docker build --platform linux/amd64 -t ado-agent:latest .

docker tag ado-agent:latest aws_account_id.dkr.ecr.region.amazonaws.com/webapp:latest

docker push aws_account_id.dkr.ecr.region.amazonaws.com/webapp:latest

Sostituisci aws_account_id e region con il tuo Account AWS ID e. Regione AWS

Genera un token di accesso personale di Azure.

L'agente in esecuzione sul cluster privato Amazon EKS richiede un token di accesso personale (PAT) per potersi autenticare con l'account Azure DevOps . Per generare un PAT, usa i seguenti passaggi:

apiVersion: v1
kind: Secret
metadata:
  name: azdevops-pat
  namespace: default
type: Opaque
stringData:
  AZP_TOKEN: <PAT Token>

kubectl create -f ado-secret.yaml

Per ulteriori dettagli, consulta Registrare un agente utilizzando un token di accesso personale (PAT) nella documentazione Microsoft.

Utilizza il file manifest di Kubernetes per la distribuzione degli agenti.

Per distribuire l' DevOps agente di Azure sul cluster privato Amazon EKS, copia il seguente file manifest e archivia il file come: agent-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: azure-pipelines-agent-eks
  labels:
    app: azure-pipelines-agent
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-pipelines-agent
  template:
    metadata:
      labels:
        app: azure-pipelines-agent
    spec:
      containers:
      - name: docker
        image: docker:dind
        securityContext: 
          privileged: true
        volumeMounts:
        - name: shared-workspace
          mountPath: /workspace
        - name: dind-storage
          mountPath: /var/lib/docker
        env:
        - name: DOCKER_TLS_CERTDIR
          value: ""
      - name: azure-pipelines-agent
        image: aws_account_id.dkr.ecr.region.amazonaws.com/webapp:latest
        env:
        - name: AZP_URL
          value: "<Azure account URL>"
        - name: AZP_POOL
          value: "eks-agent"
        - name: AZP_TOKEN
          valueFrom:
            secretKeyRef:
              name: azdevops-pat
              key: AZP_TOKEN
        - name: AZP_AGENT_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: DOCKER_HOST
          value: tcp://localhost:2375
        volumeMounts:
        - mountPath: /workspace
          name: shared-workspace
      volumes:
      - name: dind-storage
        emptyDir: {}
      - name: shared-workspace
        emptyDir: {}

Sostituisci aws_account_id e <Azure account URL> con il tuo Account AWS ID e l'URL dell'account Azure. DevOps

Implementa l'agente sul cluster privato Amazon EKS.

Per distribuire l'agente Azure Devops sul cluster privato Amazon EKS, usa il seguente comando:

kubectl create -f agent-deployment.tf

Verifica che l'agente sia in esecuzione.

Per verificare che l' DevOps agente di Azure sia in esecuzione, usa il seguente comando:

kubectl get deploy azure-pipelines-agent-eks

L'output previsto dovrebbe essere simile al seguente:

NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
azure-pipelines-agent-eks   1/1     1            1           58s

Assicurati che la READY colonna sia visualizzata1/1.

Verifica che l'agente sia registrato nel pool di DevOps agenti di Azure.

Per verificare che l'agente sia distribuito nel cluster privato Amazon EKS e sia registrato nel pool di agentieks-agent, utilizza i seguenti passaggi:

Dovresti vedere un agente elencato con lo stato Online e il nome dell'agente dovrebbe iniziare con azure-pipelines-agent-eks -*.

Inserisci il repository di applicazioni di esempio nel tuo GitHub account.

Effettua il fork del seguente repository AWS di esempi sul tuo account: GitHub

https://github.com/aws-samples/deploy-kubernetes-resources-to- -devops amazon-eks-using-azure

Creare una pipeline.

Per creare una pipeline nel tuo DevOps account Azure, usa i seguenti passaggi:

pool:
  name: eks-agent
#pool: self-hosted # If you are running self-hosted Azure DevOps Agents

stages:
# Refering the pipeline template, input parameter that are not specified will be added with defaults
- template: ./pipeline_templates/main_template.yaml
  parameters:
    serviceConnectionName: aws-sc
    awsRegion: <your region>
    awsEKSClusterName: <name of your EKS cluster>
    projectName: webapp

Verifica che l'applicazione di esempio sia stata distribuita.

Una volta completata la pipeline, verifica la corretta implementazione dell'applicazione di esempio controllando sia il repository Amazon ECR che il cluster Amazon EKS.

Per verificare gli artefatti nel repository Amazon ECR, utilizza i seguenti passaggi:

Ad esempio 20250501.1-image e 20250501.1-helm.

Per verificare la distribuzione sul cluster Amazon EKS privato nello spazio dei nomiwebapp, usa il seguente comando:

kubectl get deploy -n webapp 

L'output previsto è il seguente:

NAME     READY   UP-TO-DATE   AVAILABLE
webapp   1/1     1            1           

Nota: se questa è la prima esecuzione della pipeline, potrebbe essere necessario autorizzare la connessione al servizio e il pool di agenti. Cerca le richieste di autorizzazione nell'interfaccia della DevOps pipeline di Azure e approvale per procedere.