Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Installieren von Kubeflow Pipelines
[Kubeflow Pipelines (KFP)](https://www.kubeflow.org/docs/components/pipelines/v2/introduction/) ist die Pipeline-Orchestrierungskomponente von Kubeflow.
Sie können Kubeflow Pipelines (KFP) auf einem vorhandenen Amazon Elastic Kubernetes Service (Amazon EKS) bereitstellen oder einen neuen Amazon EKS-Cluster erstellen. Verwenden Sie einen Gateway-Knoten, um mit Ihrem Cluster zu interagieren. Der Gateway-Knoten kann Ihr lokaler Computer oder eine Amazon-EC2-Instance sein.
Der folgende Abschnitt führt Sie durch die Schritte zur Einrichtung und Konfiguration dieser Ressourcen.
**Topics**
+ [Eine Installationsoption auswählen](#choose-install-option)
+ [Konfigurieren Sie Ihre Pipeline-Berechtigungen für den Zugriff auf SageMaker KI](#configure-permissions-for-pipeline)
+ [Greifen Sie auf die KFP-Benutzeroberfläche zu (Kubeflow Dashboard)](#access-the-kfp-ui)
## Eine Installationsoption auswählen
Kubeflow Pipelines ist als Kernkomponente der vollständigen Distribution von Kubeflow auf oder als eigenständige Installation verfügbar. AWS
Wählen Sie die Option aus, die für Ihren Anwendungsfall gilt:
1. [Vollständiger Kubeflow aktiviert AWS Bereitstellung](#full-kubeflow-deployment)
Um zusätzlich zu Kubeflow Pipelines weitere Kubeflow-Komponenten zu verwenden, wählen Sie die vollständige [AWS Distribution von Kubeflow](https://awslabs.github.io/kubeflow-manifests) Bereitstellung.
1. [Eigenständige Bereitstellung von Kubeflow Pipelines](#kubeflow-pipelines-standalone)
Um die Kubeflow-Pipelines ohne die anderen Komponenten von Kubeflow zu verwenden, installieren Sie Kubeflow-Pipelines eigenständig.
### Vollständiger Kubeflow aktiviert AWS Bereitstellung
Um die Vollversion von Kubeflow on zu installieren AWS, wählen Sie die Vanilla-Bereitstellungsoption aus dem [Kubeflow on AWS Deployment Guide](https://awslabs.github.io/kubeflow-manifests/docs/deployment/) oder eine andere Bereitstellungsoption, die Integrationen mit verschiedenen AWS Diensten (Amazon S3, Amazon RDS, Amazon Cognito) unterstützt.
### Eigenständige Bereitstellung von Kubeflow Pipelines
In diesem Abschnitt wird davon ausgegangen, dass Ihr Benutzer berechtigt ist, Rollen zu erstellen und Richtlinien für die Rolle zu definieren.
#### Einrichten eines Gateway-Knotens
Sie können Ihren lokalen Computer oder eine Amazon-EC2-Instance als Gateway-Knoten verwenden. Ein Gateway-Knoten wird verwendet, um einen Amazon EKS-Cluster zu erstellen und auf die Kubeflow Pipelines UI zuzugreifen.
Führen Sie die folgenden Schritte aus, um Ihren Knoten einzurichten.
1.
**Erstellen Sie einen Gateway-Knoten.**
Sie können eine bestehende Amazon-EC2-Instance verwenden oder eine neue Instance mit der neuesten Ubuntu 18.04 DLAMI-Version erstellen, indem Sie die Schritte unter [Starten und Konfigurieren einer DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) ausführen.
1.
**Erstellen Sie eine IAM-Rolle, um Ihrem Gateway-Knoten Zugriff zu gewähren AWS Ressourcen schätzen.**
Erstellen Sie eine IAM-Rolle mit Berechtigungen für die folgenden Ressourcen: CloudWatch,, IAM CloudFormation, Amazon EC2, Amazon S3, Amazon EKS.
Weisen Sie der IAM-Rolle die folgenden Richtlinien zu:
+ CloudWatchLogsFullAccess
+ [https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCloudFormationFullAccess](https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCloudFormationFullAccess)
+ IAMFullAccess
+ AmazonS3FullAccess
+ AmazonEC2FullAccess
+ AmazonEKSAdminPolicy (Erstellen Sie diese Richtlinie mithilfe des Schemas aus den [Amazon Identity-Based EKS-Richtlinienbeispielen](https://docs.aws.amazon.com/eks/latest/userguide/security_iam_id-based-policy-examples.html))
Informationen zum Hinzufügen von IAM-Berechtigungen zu einer IAM-Rolle finden Sie unter [Hinzufügen und Entfernen von IAM-Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
1.
**Installieren Sie die folgenden Tools und Clients**
Installieren und konfigurieren Sie die folgenden Tools und Ressourcen auf Ihrem Gateway-Knoten, um auf den Amazon EKS-Cluster und die KFP-Benutzeroberfläche (UI) zuzugreifen.
+ [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html): Das Befehlszeilentool für die Arbeit mit AWS Diensten. Informationen zur AWS CLI Konfiguration finden Sie unter [Konfiguration von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
+ [aws-iam-authenticator](https://docs.aws.amazon.com/eks/latest/userguide/install-aws-iam-authenticator.html) Version 0.1.31 und höher: Ein Tool zur Verwendung von AWS IAM-Anmeldeinformationen für die Authentifizierung bei einem Kubernetes-Cluster.
+ [https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) Version über 0.15: Das Befehlszeilentool für die Arbeit mit Amazon EKS-Clustern.
+ [https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl) – Das Befehlszeilenwerkzeug für die Arbeit mit Kubernetes-Clustern. Die Version muss innerhalb einer Nebenversion mit Ihrer Kubernetes-Version übereinstimmen.
+ [https://aws.amazon.com/sdk-for-python/](https://aws.amazon.com/sdk-for-python/).
```
pip install boto3
```
#### Einrichten eines Amazon EKS-Clusters
1. Wenn Sie noch keinen Amazon EKS-Cluster haben, führen Sie die folgenden Schritte von der Befehlszeile Ihres Gateway-Knotens aus. Andernfalls überspringen Sie diesen Schritt.
1. Führen Sie den folgenden Befehl aus, um einen Amazon EKS-Cluster mit Version 1.17 oder höher zu erstellen. Ersetzen Sie `` durch einen beliebigen Namen für Ihren Cluster.
```
eksctl create cluster --name {{}} --region us-east-1 --auto-kubeconfig --timeout=50m --managed --nodes=1
```
1. Wenn die Cluster-Erstellung abgeschlossen ist, stellen Sie sicher, dass Sie Zugriff auf Ihren Cluster haben, indem Sie die Knoten des Clusters auflisten.
```
kubectl get nodes
```
1. Stellen Sie mit dem folgenden Befehl sicher, dass der aktuelle `kubectl` Kontext auf Ihren Cluster verweist. Der aktuelle Kontext ist in der Ausgabe mit einem Sternchen (\*) gekennzeichnet.
```
kubectl config get-contexts
CURRENT NAME CLUSTER
* {{}}@{{}}.us-east-1.eksctl.io {{}}.us-east-1.eksctl.io
```
1. Wenn der gewünschte Cluster nicht als Ihr aktueller Standard konfiguriert ist, aktualisieren Sie den Standard mit dem folgenden Befehl.
```
aws eks update-kubeconfig --name {{}} --region us-east-1
```
#### Installieren von Kubeflow Pipelines
Führen Sie die folgenden Schritte vom Terminal Ihres Gateway-Knotens aus, um Kubeflow Pipelines auf Ihrem Cluster zu installieren.
1. Installieren Sie alle [Cert-Manager-Komponenten](https://cert-manager.io/docs/installation/kubectl/).
```
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.9.1/cert-manager.yaml
```
1. Installieren Sie die Kubeflow-Pipelines.
```
export PIPELINE_VERSION=2.0.0-alpha.5
kubectl apply -k "github.com/kubeflow/pipelines/manifests/kustomize/env/cert-manager/cluster-scoped-resources?ref=$KFP_VERSION"
kubectl wait --for condition=established --timeout=60s crd/applications.app.k8s.io
kubectl apply -k "github.com/kubeflow/pipelines/manifests/kustomize/env/cert-manager/dev?ref=$KFP_VERSION"
```
1. Stellen Sie sicher, dass der Kubeflow Pipelines Service und andere zugehörige Ressourcen laufen.
```
kubectl -n kubeflow get all | grep pipeline
```
Die Ausgabe sollte wie folgt aussehen.
```
pod/ml-pipeline-6b88c67994-kdtjv 1/1 Running 0 2d
pod/ml-pipeline-persistenceagent-64d74dfdbf-66stk 1/1 Running 0 2d
pod/ml-pipeline-scheduledworkflow-65bdf46db7-5x9qj 1/1 Running 0 2d
pod/ml-pipeline-ui-66cc4cffb6-cmsdb 1/1 Running 0 2d
pod/ml-pipeline-viewer-crd-6db65ccc4-wqlzj 1/1 Running 0 2d
pod/ml-pipeline-visualizationserver-9c47576f4-bqmx4 1/1 Running 0 2d
service/ml-pipeline ClusterIP 10.100.170.170 8888/TCP,8887/TCP 2d
service/ml-pipeline-ui ClusterIP 10.100.38.71 80/TCP 2d
service/ml-pipeline-visualizationserver ClusterIP 10.100.61.47 8888/TCP 2d
deployment.apps/ml-pipeline 1/1 1 1 2d
deployment.apps/ml-pipeline-persistenceagent 1/1 1 1 2d
deployment.apps/ml-pipeline-scheduledworkflow 1/1 1 1 2d
deployment.apps/ml-pipeline-ui 1/1 1 1 2d
deployment.apps/ml-pipeline-viewer-crd 1/1 1 1 2d
deployment.apps/ml-pipeline-visualizationserver 1/1 1 1 2d
replicaset.apps/ml-pipeline-6b88c67994 1 1 1 2d
replicaset.apps/ml-pipeline-persistenceagent-64d74dfdbf 1 1 1 2d
replicaset.apps/ml-pipeline-scheduledworkflow-65bdf46db7 1 1 1 2d
replicaset.apps/ml-pipeline-ui-66cc4cffb6 1 1 1 2d
replicaset.apps/ml-pipeline-viewer-crd-6db65ccc4 1 1 1 2d
replicaset.apps/ml-pipeline-visualizationserver-9c47576f4 1 1 1 2d
```
## Konfigurieren Sie Ihre Pipeline-Berechtigungen für den Zugriff auf SageMaker KI
In diesem Abschnitt erstellen Sie eine IAM-Ausführungsrolle, die Kubeflow Pipeline-Pods Zugriff SageMaker auf KI-Dienste gewährt.
### Konfiguration für SageMaker KI-Komponenten, Version 2
Um SageMaker AI Components Version 2 für Kubeflow Pipelines auszuführen, müssen Sie [SageMaker AI Operator for Kubernetes installieren und Role-Based Access Control (RBAC) konfigurieren, sodass die Kubeflow](https://github.com/aws-controllers-k8s/sagemaker-controller) Pipelines Pods benutzerdefinierte KI-Ressourcen in Ihrem Kubernetes-Cluster erstellen können. SageMaker
**Wichtig**
Folgen Sie diesem Abschnitt, wenn Sie die eigenständige Bereitstellung von Kubeflow-Pipelines verwenden. Wenn Sie die AWS Distribution von Kubeflow Version 1.6.0-aws-b1.0.0 oder höher verwenden, sind die KI-Komponenten Version 2 bereits eingerichtet. SageMaker
1. Installieren Sie SageMaker AI Operator for Kubernetes, um die KI-Komponenten Version 2 zu verwenden. SageMaker
Folgen Sie dem Abschnitt „*Einrichtung*“ des [Tutorials „Machine Learning mit SageMaker ACK AI Controller](https://aws-controllers-k8s.github.io/community/docs/tutorials/sagemaker-example/#setup)“.
1. Konfigurieren Sie RBAC-Berechtigungen für die Ausführungsrolle (Service-Konto), die von den Kubeflow Pipelines-Pods verwendet wird. Bei der eigenständigen Bereitstellung von Kubeflow-Pipelines werden die Pipelineläufe im namespace`kubeflow` unter Verwendung des Service-Kontos `pipeline-runner` ausgeführt.
1. Erstellen Sie eine [RoleBinding](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-example), die dem Dienstkonto die Erlaubnis erteilt, benutzerdefinierte SageMaker KI-Ressourcen zu verwalten.
```
cat > manage_sagemaker_cr.yaml <
Um SageMaker AI Components Version 1 für Kubeflow Pipelines ausführen zu können, benötigen die Kubeflow Pipeline-Pods Zugriff auf KI. SageMaker
**Wichtig**
Folgen Sie diesem Abschnitt, unabhängig davon, ob Sie die vollständige Version von Kubeflow bei der Bereitstellung oder die eigenständige Version von Kubeflow Pilepines verwenden. AWS
Gehen Sie wie folgt vor, um eine IAM-Ausführungsrolle zu erstellen, die den Kubeflow-Pipeline-Pods Zugriff auf KI gewährt: SageMaker
1. Exportieren Sie Ihren Clusternamen (z. B. *my-cluster-name*) und Ihre Cluster-Region (z. B. *us-east-1*).
```
export CLUSTER_NAME={{my-cluster-name}}
export CLUSTER_REGION={{us-east-1}}
```
1. Exportieren Sie den Namespace und den Namen des Service-Kontos entsprechend Ihrer Installation.
+ *Um den vollständigen Kubeflow bei der AWS Installation zu erhalten, exportieren Sie Ihr Profil `namespace` (z. B. *kubeflow-user-example-com*) und den Standardeditor als Dienstkonto.*
```
export NAMESPACE={{kubeflow-user-example-com}}
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=default-editor
```
+ Exportieren Sie für die eigenständige Pipelines-Bereitstellung *Kubeflow* als `namespace` und *Pipeline-Runner* als Service-Konto.
```
export NAMESPACE=kubeflow
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=pipeline-runner
```
1. Erstellen Sie einen [ IAM OIDC-Anbieter für den Amazon EKS-Cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) mit dem folgenden Befehl.
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \
--region ${CLUSTER_REGION} --approve
```
1. Erstellen Sie eine IAM-Ausführungsrolle für die KFP-Pods, um auf Dienste (AI,) zuzugreifen. AWS SageMaker CloudWatch
```
eksctl create iamserviceaccount \
--name ${KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT} \
--namespace ${NAMESPACE} --cluster ${CLUSTER_NAME} \
--region ${CLUSTER_REGION} \
--attach-policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--override-existing-serviceaccounts \
--approve
```
[Sobald Ihre Pipeline-Berechtigungen für den Zugriff auf SageMaker AI Components Version 1 konfiguriert sind, folgen Sie dem Leitfaden SageMaker KI-Komponenten für Kubeflow-Pipelines in der Kubeflow-Dokumentation. AWS](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/)
## Greifen Sie auf die KFP-Benutzeroberfläche zu (Kubeflow Dashboard)
Die Kubeflow Pipelines UI wird für die Verwaltung und Nachverfolgung von Experimenten, Aufträge und Läufen in Ihrem Cluster verwendet. Anweisungen zum Zugriff auf die Kubeflow Pipelines UI von Ihrem Gateway-Knoten aus finden Sie in diesem Abschnitt in den Schritten, die für Ihre Bereitstellungsoption gelten.
### Vollständiger Kubeflow aktiviert AWS Bereitstellung
Folgen Sie den Anweisungen auf der [Kubeflow AWS on-Website](https://awslabs.github.io/kubeflow-manifests/docs/deployment/connect-kubeflow-dashboard/), um eine Verbindung zum Kubeflow-Dashboard herzustellen und zur Registerkarte Pipelines zu navigieren.
### Eigenständige Bereitstellung von Kubeflow-Pipelines
Verwenden Sie die Portweiterleitung, um von Ihrem Gateway-Knoten aus auf die Benutzeroberfläche von Kubeflow Pipelines zuzugreifen, indem Sie die folgenden Schritte ausführen.
#### Richten Sie die Portweiterleitung zum KFP UI-Service ein
Führen Sie den folgenden Befehl von der Befehlszeile Ihres Gateway-Knotens aus.
1. Vergewissern Sie sich mit folgendem Befehl, dass der KFP-UI-Service ausgeführt wird.
```
kubectl -n kubeflow get service ml-pipeline-ui
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
ml-pipeline-ui ClusterIP 10.100.38.71 80/TCP 2d22h
```
1. Führen Sie den folgenden Befehl aus, um die Portweiterleitung zum KFP UI Service einzurichten. Dadurch wird die KFP-Benutzeroberfläche an Port 8080 auf Ihrem Gateway-Knoten weitergeleitet und Sie können von Ihrem Browser aus auf die KFP-Benutzeroberfläche zugreifen.
```
kubectl port-forward -n kubeflow service/ml-pipeline-ui 8080:80
```
Die Portweiterleitung von Ihrem Remote-Computer wird unterbrochen, wenn keine Aktivität stattfindet. Führen Sie diesen Befehl erneut aus, wenn Ihr Dashboard keine Protokolle oder Updates abrufen kann. Wenn die Befehle einen Fehler zurückgeben, stellen Sie sicher, dass auf dem Port, den Sie verwenden möchten, bereits kein Prozess läuft.
#### Greifen Sie auf den KFP-UI-Service zu
Ihre Methode für den Zugriff auf die KFP-Benutzeroberfläche hängt von Ihrem Gateway-Knotentyp ab.
+ Lokaler Computer als Gateway-Knoten:
1. Greifen Sie wie folgt auf das Dashboard in Ihrem Browser zu:
```
http://localhost:8080
```
1. Wählen Sie **Pipelines**, um auf die Pipeline-Benutzeroberfläche zuzugreifen.
+ Amazon-EC2-Instance als Gateway-Knoten:
1. Sie müssen einen SSH-Tunnel auf Ihrer Amazon-EC2-Instance einrichten, um über den Browser Ihres lokalen Computers auf das Kubeflow-Dashboard zuzugreifen.
Führen Sie in einer neuen Terminalsitzung auf Ihrem lokalen Computer Folgendes aus. Ersetzen Sie `` durch die IP-Adresse Ihrer Instance auf der Amazon-EC2-Konsole. Sie können auch das öffentliche DNS verwenden. Ersetzen Sie `` durch den Pfad zu dem PEM-Schlüssel, der für den Zugriff auf den Gateway-Knoten verwendet wird.
```
public_DNS_address={{}}
key={{}}
on Ubuntu:
ssh -i ${key} -L 9000:localhost:8080 ubuntu@${public_DNS_address}
or on Amazon Linux:
ssh -i ${key} -L 9000:localhost:8080 ec2-user@${public_DNS_address}
```
1. Greifen Sie in Ihrem Browser auf das Dashboard zu.
```
http://localhost:9000
```
1. Wählen Sie **Pipelines**, um auf die KFP-Benutzeroberfläche zuzugreifen.
#### (Optional) Gewähren Sie SageMaker KI-Notebook-Instances Zugriff auf Amazon EKS und führen Sie KFP-Pipelines von Ihrem Notebook aus aus aus.
Eine SageMaker Notebook-Instance ist eine vollständig verwaltete Amazon EC2 EC2-Recheninstanz, auf der die Jupyter Notebook App ausgeführt wird. Sie können eine Notebook-Instance verwenden, um Jupyter Notebooks zu erstellen und zu verwalten und dann Ihre KFP-Pipelines mithilfe von AWS SDK für Python (Boto3) oder der KFP-CLI zu definieren, zu kompilieren, bereitzustellen und auszuführen.
1. Folgen Sie den Schritten unter Notebook-Instance [erstellen, um Ihre SageMaker Notebook-Instance](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html) zu erstellen, und fügen Sie dann die `S3FullAccess` Richtlinie der zugehörigen IAM-Ausführungsrolle hinzu.
1. Führen Sie in der Befehlszeile Ihres Gateway-Knotens den folgenden Befehl aus, um den IAM-Rollen-ARN der von Ihnen erstellten Notebook-Instance abzurufen. Ersetzen Sie `` durch den Namen Ihrer Instance.
```
aws sagemaker describe-notebook-instance --notebook-instance-name {{}} --region {{}} --output text --query 'RoleArn'
```
Dieser Befehl gibt die IAM-Rolle ARN im folgenden `arn:aws:iam:::role/` Format aus. Notieren Sie sich diesen ARN.
1. Führen Sie diesen Befehl aus, um die folgenden Richtlinien (AmazonSageMakerFullAccess, AmazonEKSWorkerNodePolicy, AmazonS3FullAccess) an diese IAM-Rolle anzuhängen. Ersetzen Sie `` durch `` in Ihrem ARN.
```
aws iam attach-role-policy --role-name {{}} --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
aws iam attach-role-policy --role-name {{}} --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
aws iam attach-role-policy --role-name {{}} --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
```
1. Amazon EKS-Cluster verwenden IAM-Rollen, um den Zugriff auf den Cluster zu steuern. Die Regeln sind in einer Konfigurationsübersicht mit dem Namen `aws-auth` implementiert. `eksctl` stellt Befehle zum Lesen und Bearbeiten der `aws-auth` Config-Map bereit. Nur Benutzer, die Zugriff auf den Cluster haben, können diese Konfigurationsübersicht bearbeiten.
`system:masters` ist eine der Standardbenutzergruppen mit Superuser-Rechten für den Cluster. Fügen Sie Ihren Benutzer zu dieser Gruppe hinzu oder erstellen Sie eine Gruppe mit restriktiveren Berechtigungen.
1. Binden Sie die Rolle an Ihren Cluster, indem Sie den folgenden Befehl ausführen. Ersetzen Sie `` durch den ARN der IAM-Rolle. `` kann ein beliebiger eindeutiger Benutzername sein.
```
eksctl create iamidentitymapping \
--cluster {{}} \
--arn {{}} \
--group system:masters \
--username {{}} \
--region {{}}
```
1. Öffnen Sie ein Jupyter-Notebook auf Ihrer SageMaker AI-Instanz und führen Sie den folgenden Befehl aus, um sicherzustellen, dass es Zugriff auf den Cluster hat.
```
aws eks --region {{}} update-kubeconfig --name {{}}
kubectl -n kubeflow get all | grep pipeline
```