As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Instalar Pipelines do Kubeflow
[O Kubeflow Pipelines (KFP)](https://www.kubeflow.org/docs/components/pipelines/v2/introduction/) é o componente de orquestração de pipeline do Kubeflow.
Você pode implantar o Kubeflow Pipelines (KFP) em um Amazon Elastic Kubernetes Service (Amazon EKS) existente ou criar um novo cluster do Amazon EKS. Use um nó de gateway para interagir com seu cluster. O nó do gateway pode ser sua máquina local ou uma instância do Amazon EC2.
A seção a seguir orienta você pelas etapas de instalação e configuração desses recursos.
**Topics**
+ [Escolha uma opção de instalação](#choose-install-option)
+ [Configure suas permissões de pipeline para acessar a SageMaker IA](#configure-permissions-for-pipeline)
+ [Acesse a interface do usuário do KFP (painel do Kubeflow)](#access-the-kfp-ui)
## Escolha uma opção de instalação
O Kubeflow Pipelines está disponível como um componente principal da distribuição completa do Kubeflow em AWS ou como uma instalação independente.
Selecione a opção que se aplica ao seu caso de uso:
1. [Kubeflow completo na implantação AWS](#full-kubeflow-deployment)
Para usar outros componentes do Kubeflow além dos Pipelines do Kubeflow, escolha a [distribuição completa AWS da implantação do Kubeflow](https://awslabs.github.io/kubeflow-manifests).
1. [Implantação autônoma do Kubeflow Pipelines](#kubeflow-pipelines-standalone)
Para usar os pipelines do Kubeflow sem os outros componentes do Kubeflow, instale os pipelines do Kubeflow de forma independente.
### Kubeflow completo na implantação AWS
Para instalar a versão completa do Kubeflow on AWS, escolha a opção de implantação básica no [guia de implantação do Kubeflow on ou qualquer outra opção de AWS implantação](https://awslabs.github.io/kubeflow-manifests/docs/deployment/) que ofereça suporte a integrações com vários serviços ( AWS Amazon S3, Amazon RDS, Amazon Cognito).
### Implantação autônoma do Kubeflow Pipelines
Esta seção pressupõe que seu usuário tenha permissões para criar funções e definir políticas para a função.
#### Configurar um nó de gateway
Você pode usar sua máquina local ou uma instância do Amazon EC2 como seu nó de gateway. Um nó de gateway é usado para criar um cluster do Amazon EKS e acessar a interface do usuário do Kubeflow Pipelines.
Concluir as etapas a seguir para configurar seu nó.
1.
**Criar um nó de gateway.**
Você pode usar uma instância existente do Amazon EC2 ou criar uma nova instância com a versão mais recente da DLAMI do Ubuntu 18.04 usando as etapas em [Iniciar e configurar uma DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html).
1.
**Crie uma função do IAM para conceder acesso aos AWS recursos do nó do gateway.**
Crie uma função do IAM com permissões para os seguintes recursos: CloudWatch,, IAM CloudFormation, Amazon EC2, Amazon S3, Amazon EKS.
Anexe as políticas a seguir à perfil do IAM:
+ 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)
+ IAMFullAcesso
+ Amazon S3 FullAccess
+ Amazon EC2 FullAccess
+ EKSAdminPolítica da Amazon (crie essa política usando o esquema dos exemplos de políticas [baseadas em identidade do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security_iam_id-based-policy-examples.html))
Para obter informações sobre como adicionar Permissões do IAM a um perfil do IAM consulte [Adicionando e removendo permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
1.
**Instale as seguintes ferramentas e clientes**
Instale e configure as seguintes ferramentas e recursos em seu nó de gateway para acessar o cluster do Amazon EKS e a interface de usuário (UI) do KFP:
+ [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html): A ferramenta de linha de comando para trabalhar com AWS serviços. Para obter informações de AWS CLI configuração, consulte [Configurando o 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)versão 0.1.31 e superior: uma ferramenta para usar credenciais AWS do IAM para se autenticar em um cluster Kubernetes.
+ A versão [https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) acima de 0,15: a ferramenta de linha de comando para trabalhar com clusters do Amazon EKS.
+ [https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/#install-kubectl): a ferramenta de linha de comando para trabalhar com clusters do Kubernetes. A versão precisa corresponder à sua versão do Kubernetes em uma versão secundária.
+ [https://aws.amazon.com/sdk-for-python/](https://aws.amazon.com/sdk-for-python/).
```
pip install boto3
```
#### Configuração de um cluster do Amazon EKS
1. Se você não tiver um cluster do Amazon EKS existente, execute as seguintes etapas na linha de comando do seu nó de gateway; caso contrário, pule essa etapa:
1. Execute o comando a seguir para criar um cluster do Amazon EKS com a versão 1.17 ou superior. Substitua `` por qualquer nome para seu cluster.
```
eksctl create cluster --name --region us-east-1 --auto-kubeconfig --timeout=50m --managed --nodes=1
```
1. Quando a criação do cluster estiver concluída, certifique-se de ter acesso ao seu cluster listando os nós do cluster.
```
kubectl get nodes
```
1. Certifique-se de que o `kubectl` contexto atual aponte para seu cluster com o seguinte comando: O contexto atual é marcado com um asterisco (\$1) na saída.
```
kubectl config get-contexts
CURRENT NAME CLUSTER
* @.us-east-1.eksctl.io .us-east-1.eksctl.io
```
1. Se o cluster desejado não estiver configurado como padrão atual, atualize o padrão com o comando a seguir.
```
aws eks update-kubeconfig --name --region us-east-1
```
#### Instalar Pipelines do Kubeflow
Execute as etapas a seguir no terminal do seu nó de gateway para instalar o Kubeflow Pipelines em seu cluster.
1. Instale todos os [componentes do cert-manager](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. Instale os pipelines do Kubeflow.
```
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. Certifique-se de que o serviço Kubeflow Pipelines e outros recursos relacionados estejam em execução.
```
kubectl -n kubeflow get all | grep pipeline
```
A saída será semelhante à seguinte:
```
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
```
## Configure suas permissões de pipeline para acessar a SageMaker IA
Nesta seção, você cria uma função de execução do IAM que concede aos pods do Kubeflow Pipeline acesso aos serviços de IA. SageMaker
### Configuração para componentes de SageMaker IA versão 2
Para executar o SageMaker AI Components versão 2 para o Kubeflow Pipelines, você precisa instalar o [SageMaker AI Operator for Kubernetes](https://github.com/aws-controllers-k8s/sagemaker-controller) e configurar o Role-Based Access Control (RBAC), permitindo que os pods do Kubeflow Pipelines criem recursos personalizados de IA em seu cluster Kubernetes. SageMaker
**Importante**
Siga esta seção se você estiver usando a implantação autônoma do Kubeflow pipelines. Se você estiver usando a AWS distribuição do Kubeflow versão 1.6.0-aws-b1.0.0 ou superior, os componentes de IA versão 2 já estão configurados SageMaker .
1. Instale o SageMaker AI Operator for Kubernetes para usar os componentes de SageMaker IA versão 2.
Siga a seção *Configuração* do [tutorial Machine Learning with ACK SageMaker AI Controller](https://aws-controllers-k8s.github.io/community/docs/tutorials/sagemaker-example/#setup).
1. Configure as permissões do RBAC para a função de execução (conta de serviço) usada pelos pods do Kubeflow Pipelines. Na implantação autônoma do Kubeflow Pipelines, as execuções do pipeline são executadas no namespace `kubeflow` usando a conta de serviço `pipeline-runner`.
1. Crie um [RoleBinding](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-example)que dê permissão à conta de serviço para gerenciar recursos personalizados de SageMaker IA.
```
cat > manage_sagemaker_cr.yaml <
Para executar a versão 1 do SageMaker AI Components para o Kubeflow Pipelines, os pods do Kubeflow Pipeline precisam acessar a IA. SageMaker
**Importante**
Siga esta seção se você estiver usando o Kubeflow completo na AWS implantação ou o Kubeflow Pilepines autônomo.
Para criar uma função de execução do IAM que conceda aos pods do pipeline Kubeflow acesso à SageMaker IA, siga estas etapas:
1. Exporte o nome do cluster (por exemplo, *my-cluster-name*) e a região do cluster (por exemplo, *us-east-1*).
```
export CLUSTER_NAME=my-cluster-name
export CLUSTER_REGION=us-east-1
```
1. Exporte o namespace e o nome da conta de serviço de acordo com sua instalação.
+ Para obter o Kubeflow completo na AWS instalação, exporte seu perfil `namespace` (por exemplo, *kubeflow-user-example-com*) e o *editor padrão como a conta de serviço*.
```
export NAMESPACE=kubeflow-user-example-com
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=default-editor
```
+ Para a implantação autônoma do Pipelines, exporte o *kubeflow* como a `namespace` e o *pipeline-runner* como a conta de serviço.
```
export NAMESPACE=kubeflow
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=pipeline-runner
```
1. Criar um o provedor [IAM OIDC para o cluster do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) com o comando a seguir.
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \
--region ${CLUSTER_REGION} --approve
```
1. Crie uma função de execução do IAM para que os pods do KFP acessem os AWS serviços (SageMaker AI,). 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
```
Depois que suas permissões de pipeline estiverem configuradas para acessar a versão 1 dos componentes de SageMaker IA, siga o guia de componentes de SageMaker IA para pipelines do Kubeflow na documentação do [Kubeflow](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/) on. AWS
## Acesse a interface do usuário do KFP (painel do Kubeflow)
A interface do usuário do Kubeflow Pipelines é usada para gerenciar e monitorar experimentos, trabalhos e execuções em seu cluster. Para obter instruções sobre como acessar a interface do usuário do Kubeflow Pipelines a partir do nó do gateway, siga as etapas que se aplicam à sua opção de implantação nesta seção.
### Kubeflow completo na implantação AWS
Siga as instruções no [AWS site do Kubeflow on](https://awslabs.github.io/kubeflow-manifests/docs/deployment/connect-kubeflow-dashboard/) para se conectar ao painel do Kubeflow e navegar até a guia Pipelines.
### Implantação autônoma do Kubeflow Pipelines
Use o encaminhamento de portas para acessar a interface do usuário do Kubeflow Pipelines a partir do nó do gateway seguindo essas etapas.
#### Configurar o encaminhamento de portas para o serviço KFP UI
Execute o comando a seguir na linha de comando do nó do gateway.
1. Verifique que o serviço KFP UI está em execução usando o comando a seguir.
```
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. Execute o comando a seguir para configurar o encaminhamento de portas para o serviço de interface do KFP. Isso encaminha a interface do usuário do KFP para a porta 8080 no nó do gateway e permite que você acesse a interface do KFP a partir do seu navegador.
```
kubectl port-forward -n kubeflow service/ml-pipeline-ui 8080:80
```
A porta de encaminhamento da sua máquina remota é interrompida se não houver atividade. Execute esse comando novamente se o painel não conseguir obter logs ou atualizações. Se os comandos retornarem um erro, verifique se não há nenhum processo em execução na porta que você está tentando usar.
#### Acesse o serviço KFP UI
Seu método de acessar a interface do usuário do KFP depende do tipo de nó do gateway.
+ Máquina local como nó do gateway:
1. Acesse o painel em seu navegador da seguinte forma:
```
http://localhost:8080
```
1. Escolha **Pipelines** para acessar a interface do usuário dos pipelines.
+ Instância do Amazon EC2 como nó do gateway:
1. Você precisa configurar um túnel SSH na sua instância do Amazon EC2 para acessar o painel do Kubeflow a partir do navegador da sua máquina local.
Em uma nova sessão de terminal em sua máquina local, execute o seguinte: Substitua `` pelo endereço IP da sua instância encontrado no console do Amazon EC2. Você também pode usar o DNS público. Substitua `` pelo caminho para a chave pem usada para acessar o nó do gateway.
```
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. Acesse o painel no seu navegador.
```
http://localhost:9000
```
1. Escolha **Pipelines** para acessar a interface do usuário do KFP.
#### (Opcional) Conceda às instâncias de notebook de SageMaker IA acesso ao Amazon EKS e execute pipelines do KFP a partir do seu notebook.
Uma instância de SageMaker notebook é uma instância computacional totalmente gerenciada do Amazon EC2 que executa o aplicativo Jupyter Notebook. Você pode usar uma instância de caderno para criar e gerenciar cadernos Jupyter e, em seguida, definir, compilar, implantar e executar seus pipelines do KFP usando ou a CLI do KFP AWS SDK para Python (Boto3) .
1. Siga as etapas em [Criar uma instância de SageMaker notebook para criar sua instância](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html) de notebook e, em seguida, anexe a `S3FullAccess` política à função de execução do IAM.
1. Na linha de comando do seu nó do gateway, execute o comando a seguir para recuperar o ARN da função IAM da instância do caderno que você criou. Substitua `` pelo nome da sua instância.
```
aws sagemaker describe-notebook-instance --notebook-instance-name --region --output text --query 'RoleArn'
```
Esse comando gera o ARN do perfil do IAM no `arn:aws:iam:::role/` formato. Anote este ARN.
1. Execute esse comando para anexar as seguintes políticas (Amazon AmazonSageMakerFullAccess EKSWorkerNodePolicy, AmazonS3FullAccess) a essa função do IAM. Substitua `` com `` em seu 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. Os clusters do Amazon EKS usam funções do IAM para controlar o acesso ao cluster. As regras são implementadas em um mapa de configuração chamado `aws-auth`. `eksctl` fornece comandos para ler e editar o mapa de configuração `aws-auth`. Somente os usuários que têm acesso ao cluster podem editar esse mapa de configuração.
`system:masters`é um dos grupos de usuários padrão com permissões de superusuário no cluster. Adicione seu usuário a esse grupo ou crie um grupo com permissões mais restritivas.
1. Vincule a função ao seu cluster executando o comando a seguir. Substituir `` pelo ARN da perfil do IAM. `` pode ser qualquer nome de usuário exclusivo.
```
eksctl create iamidentitymapping \
--cluster \
--arn \
--group system:masters \
--username \
--region
```
1. Abra um notebook Jupyter na sua instância de SageMaker IA e execute o comando a seguir para garantir que ele tenha acesso ao cluster.
```
aws eks --region update-kubeconfig --name
kubectl -n kubeflow get all | grep pipeline
```