Stellen Sie Workloads aus DevOps Azure-Pipelines auf private Amazon EKS-Cluster bereit

Suchen Sie die DevOps Azure-Organisations-GUID.

Melden Sie sich bei Ihrem DevOps Azure-Konto an, und verwenden Sie dann die folgende URL, um die Organisations-GUID zu finden: https://dev.azure.com/{DevOps_Org_ID}/_apis/projectCollections?api-version=6.0 {DevOps_org_ID} Ersetzen Sie die URL durch Ihre DevOps Azure-Organisations-ID.

Konfigurieren Sie einen IdP in der AWS-Konto.

Gehen Sie wie folgt vor, um einen Identitätsanbieter (IdP) in der AWS-Konto für eine Azure-Dienstverbindung zu konfigurieren:

Weitere Informationen finden Sie unter So stellen Sie DevOps mithilfe AWS von OpenID Connect eine Verbindung zu Azure her.

Erstellen Sie eine IAM-Richtlinie in der AWS-Konto.

Gehen Sie wie folgt vor, um eine IAM-Richtlinie zu erstellen, um die erforderlichen Berechtigungen für die von der DevOps Azure-Pipeline verwendete IAM-Rolle bereitzustellen:

Erstellen Sie eine IAM-Rolle in der AWS-Konto.

Gehen Sie wie folgt vor, um eine IAM-Rolle AWS-Konto für die Azure-Dienstverbindung zu konfigurieren:

{
  "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}"
        }
      }
    }
  ]
}

Geben Sie in der Richtlinie Ihre Informationen für die folgenden Platzhalter an:

Erstellen Sie eine Dienstverbindung im DevOps Azure-Konto.

Gehen Sie wie folgt vor, um eine Azure-Dienstverbindung zu konfigurieren:

Weitere Informationen finden Sie in der Microsoft-Dokumentation unter Erstellen einer Dienstverbindung.

Fügen Sie die IAM-Rolle zur Amazon EKS-Konfigurationsdatei hinzu.

Die IAM-Rolle muss über die erforderlichen Berechtigungen verfügen, um die erforderlichen Operationen auf dem Amazon EKS-Cluster auszuführen. Da es sich um eine Pipeline-Rolle handelt, muss die IAM-Rolle in der Lage sein, fast alle Arten von Ressourcen im Cluster zu verwalten. Daher ist die system:masters Gruppenberechtigung für diese Rolle geeignet.

Verwenden Sie den folgenden Code, um die erforderliche Konfiguration aws-auth ConfigMap innerhalb von Kubernetes hinzuzufügen:

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

Ersetze es {account_id} durch deine ID AWS-Konto .

Weitere Informationen finden Sie unter So funktioniert Amazon EKS mit IAM in der Amazon EKS-Dokumentation.

Erstellen Sie einen selbst gehosteten Agentenpool.

Gehen Sie wie folgt vor, um einen selbst gehosteten Agentpool im DevOps Azure-Konto zu konfigurieren:

Weitere Informationen finden Sie in der Microsoft-Dokumentation unter Agentenpools erstellen und verwalten.

Erstellen Sie ein Amazon-ECR-Repository.

Die Docker-Images, die zur Bereitstellung des DevOps Azure-Agenten und der Beispielanwendung (webapp) auf dem privaten Amazon EKS-Cluster verwendet werden, müssen in einem Amazon ECR-Repository gespeichert werden. Gehen Sie wie folgt vor, um ein Amazon ECR-Repository zu erstellen:

Weitere Informationen finden Sie unter Erstellen eines privaten Amazon ECR-Repositorys zum Speichern von Bildern in der Amazon ECR-Dokumentation.

Erstellen Sie ein Dockerfile, um den DevOps Azure-Agenten zu erstellen.

Erstellen Sie ein Dockerfile, um das Docker-Image zu erstellen, auf dem der Azure-Agent installiert ist. DevOps Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen: 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" ]

Erstellen Sie ein Skript für den DevOps Azure-Agenten.

Gehen Sie wie folgt vor, um das start.sh Skript zu erstellen:

Erstellen Sie ein Docker-Image mit dem DevOps Azure-Agenten.

Um ein Docker-Image für die Installation des DevOps Azure-Agenten zu erstellen, verwenden Sie das Dockerfile, das Sie zuvor erstellt haben, um das Image zu erstellen. Führen Sie in demselben Verzeichnis, in dem das Dockerfile gespeichert ist, die folgenden Befehle aus:

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

Ersetzen Sie aws_account_id und region durch Ihre AWS-Konto ID und. AWS-Region

Generieren Sie ein Azure-Token für den persönlichen Zugriff.

Der Agent, der auf dem privaten Amazon EKS-Cluster ausgeführt wird, benötigt ein Personal Access Token (PAT), damit er sich mit dem DevOps Azure-Konto authentifizieren kann. Gehen Sie wie folgt vor, um eine PAT zu generieren:

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

kubectl create -f ado-secret.yaml

Weitere Informationen finden Sie in der Microsoft-Dokumentation unter Registrieren eines Agenten mithilfe eines Personal Access Tokens (PAT).

Verwenden Sie die Kubernetes-Manifestdatei für die Agentenbereitstellung.

Um den DevOps Azure-Agenten auf dem privaten Amazon EKS-Cluster bereitzustellen, kopieren Sie die folgende Manifestdatei und speichern Sie die Datei alsagent-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: {}

Ersetzen Sie aws_account_id und <Azure account URL> durch Ihre AWS-Konto ID und die DevOps Azure-Konto-URL.

Stellen Sie den Agenten auf dem privaten Amazon EKS-Cluster bereit.

Verwenden Sie den folgenden Befehl, um den Azure DevOps-Agenten auf dem privaten Amazon EKS-Cluster bereitzustellen:

kubectl create -f agent-deployment.tf

Stellen Sie sicher, dass der Agent läuft.

Verwenden Sie den folgenden Befehl, um zu überprüfen, ob der DevOps Azure-Agent ausgeführt wird:

kubectl get deploy azure-pipelines-agent-eks

Die erwartete Ausgabe sollte der folgenden ähneln:

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

Vergewissern Sie sich, dass die READY Spalte angezeigt wird1/1.

Stellen Sie sicher, dass der Agent im DevOps Azure-Agentenpool registriert ist.

Gehen Sie wie folgt vor, um zu überprüfen, ob der Agent auf dem privaten Amazon EKS-Cluster bereitgestellt und im Agentenpool eks-agent registriert ist:

Es sollte ein Agent mit dem Status Online aufgeführt sein, und der Name des Agenten sollte mit azure-pipelines-agent-eks -* beginnen.

Forken Sie das Repository für die Beispielanwendung in Ihr GitHub Konto ab.

Forke das folgende AWS Beispiel-Repository zu deinem GitHub Konto:

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

Erstellen Sie eine Pipeline.

Gehen Sie wie folgt vor, um eine Pipeline in Ihrem DevOps Azure-Konto zu erstellen:

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

Stellen Sie sicher, dass die Beispielanwendung bereitgestellt wurde.

Überprüfen Sie nach Abschluss der Pipeline die erfolgreiche Bereitstellung der Beispielanwendung, indem Sie sowohl das Amazon ECR-Repository als auch den Amazon EKS-Cluster überprüfen.

Gehen Sie wie folgt vor, um Artefakte im Amazon ECR-Repository zu verifizieren:

Beispiel: 20250501.1-image und 20250501.1-helm.

Verwenden Sie den folgenden Befehl, um die Bereitstellung auf dem privaten Amazon EKS-Cluster im Namespace webapp zu überprüfen:

kubectl get deploy -n webapp 

Die erwartete Ausgabe sieht wie folgt aus:

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

Hinweis: Wenn dies Ihr erster Pipeline-Lauf ist, müssen Sie möglicherweise die Serviceverbindung und den Agentenpool autorisieren. Suchen Sie in der DevOps Azure-Pipeline-Oberfläche nach Berechtigungsanfragen und genehmigen Sie sie, um fortzufahren.