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á.
# Imagens personalizadas RStudio sem SageMaker IA
Uma SageMaker imagem é um arquivo que identifica pacotes de idiomas e outras dependências necessárias para execução RStudio na Amazon SageMaker AI. SageMaker A IA usa essas imagens para criar um ambiente onde você corre RStudio. A Amazon SageMaker AI fornece uma RStudio imagem integrada para você usar. Se precisar de uma funcionalidade diferente, você pode trazer suas próprias imagens personalizadas. Esta página fornece informações sobre os principais conceitos para o uso de imagens personalizadas com RStudio SageMaker IA. O processo para usar sua própria imagem RStudio na SageMaker IA envolve três etapas:
1. Crie uma imagem personalizada a partir de um Dockerfile e envie-a para um repositório no Amazon Elastic Container Registry (Amazon ECR).
1. Crie uma SageMaker imagem que aponte para uma imagem de contêiner no Amazon ECR e anexe-a ao seu domínio Amazon SageMaker AI.
1. Inicie uma nova sessão RStudio com sua imagem personalizada.
Você pode criar imagens e versões de imagens e anexar versões de imagem ao seu domínio usando o painel de controle de SageMaker IA [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html), o e o [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/). Você também pode criar imagens e versões de imagens usando o console de SageMaker IA, mesmo que não tenha se integrado a um domínio.
Os tópicos a seguir mostram como trazer sua própria imagem para RStudio a SageMaker IA criando, anexando e lançando uma imagem personalizada.
## Terminologia básica
A seção a seguir define os principais termos para usar sua própria imagem RStudio na SageMaker IA.
+ **Dockerfile:** um Dockerfile é um arquivo que identifica os pacotes de idiomas e outras dependências da sua imagem do Docker.
+ **Imagem do Docker:** a imagem do Docker é um Dockerfile embutido. Essa imagem é verificada no Amazon ECR e serve como base para a imagem de SageMaker IA.
+ **SageMaker imagem:** uma SageMaker imagem é um suporte para um conjunto de versões de SageMaker imagem com base em imagens do Docker.
+ **Versão da imagem:** uma versão de imagem de uma SageMaker imagem representa uma imagem do Docker que é compatível RStudio e armazenada em um repositório Amazon ECR. Cada versão da imagem é imutável. Essas versões de imagem podem ser anexadas a um domínio e usadas com RStudio SageMaker IA.
# Concluir os pré-requisitos
Você deve preencher os seguintes pré-requisitos antes de usar sua própria imagem na RStudio Amazon AI. SageMaker
+ Se você tem um domínio existente RStudio que foi criado antes de 7 de abril de 2022, você deve excluir seu RStudio ServerPro aplicativo e recriá-lo. Para obter informações sobre como excluir uma aplicação, consulte [Desligue e atualize o Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
+ Instale a aplicação Docker. Para obter informações sobre como configurar o Docker, consulte [Orientação e configuração](https://docs.docker.com/get-started/).
+ Crie uma cópia local de um Dockerfile RStudio compatível que funcione com IA. SageMaker Para obter informações sobre como criar um RStudio dockerfile de amostra, consulte [Usar uma imagem personalizada para trazer seu próprio ambiente de desenvolvimento para a RStudio Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/use-a-custom-image-to-bring-your-own-development-environment-to-rstudio-on-amazon-sagemaker/).
+ Use uma função AWS Identity and Access Management de execução que tenha a [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)política anexada. Se você se integrou ao domínio, pode obter a função na seção **Resumo do domínio** do painel de controle de SageMaker IA.
Adicione as seguintes permissões de acesso ao serviço Amazon Elastic Container Registry (Amazon ECR) para seu perfil de execução:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid": "VisualEditor0",
"Effect":"Allow",
"Action":[
"ecr:CreateRepository",
"ecr:BatchGetImage",
"ecr:CompleteLayerUpload",
"ecr:DescribeImages",
"ecr:DescribeRepositories",
"ecr:UploadLayerPart",
"ecr:ListImages",
"ecr:InitiateLayerUpload",
"ecr:BatchCheckLayerAvailability",
"ecr:PutImage"
],
"Resource": "*"
}
]
}
```
------
+ Instale e configure AWS CLI com a seguinte versão (ou superior). Para obter informações sobre como instalar o AWS CLI, consulte [Instalando ou atualizando a versão mais recente do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
```
AWS CLI v1 >= 1.23.6
AWS CLI v2 >= 2.6.2
```
# Especificações de RStudio imagem personalizadas
Neste guia, você aprenderá as especificações de RStudio imagem personalizadas para usar ao trazer sua própria imagem. Há dois conjuntos de requisitos que você deve satisfazer com sua RStudio imagem personalizada para usá-la com a Amazon SageMaker AI. Esses requisitos são impostos pelo RStudio PBC e pela plataforma Amazon SageMaker Studio Classic. Se algum desses conjuntos de requisitos não for satisfeito, sua imagem personalizada não funcionará corretamente.
## RStudio Requisitos de PBC
RStudio Os requisitos de PBC estão descritos no artigo [Usando imagens do Docker com RStudio Workbench RStudio /Server Pro, Launcher](https://support.rstudio.com/hc/en-us/articles/360019253393-Using-Docker-images-with-RStudio-Server-Pro-Launcher-and-Kubernetes) e Kubernetes. Siga as instruções deste artigo para criar a base da sua RStudio imagem personalizada.
Para obter instruções sobre como instalar várias versões do R em sua imagem personalizada, consulte [Instalando várias versões do R no Linux](https://support.rstudio.com/hc/en-us/articles/215488098).
## Requisitos do Amazon SageMaker Studio Classic
O Amazon SageMaker Studio Classic impõe o seguinte conjunto de requisitos de instalação para sua RStudio imagem.
+ Você deve usar uma imagem RStudio base de pelo menos`2025.05.1+513.pro3`. Para obter mais informações, consulte [RStudio Controle de versão](rstudio-version.md).
+ Você deverá instalar os seguintes pacotes:
```
yum install -y sudo \
openjdk-11-jdk \
libpng-dev \
&& yum clean all \
&& /opt/R/${R_VERSION}/bin/R -e "install.packages('reticulate', repos='https://packagemanager.rstudio.com/cran/__linux__/centos7/latest')" \
&& /opt/python/${PYTHON_VERSION}/bin/pip install --upgrade \
'boto3>1.0<2.0' \
'awscli>1.0<2.0' \
'sagemaker[local]<3'
```
+ Você deve fornecer valores padrão para os valores do `RSTUDIO_CONNECT_URL` e do ambiente `RSTUDIO_PACKAGE_MANAGER_URL`.
```
ENV RSTUDIO_CONNECT_URL "YOUR_CONNECT_URL"
ENV RSTUDIO_PACKAGE_MANAGER_URL "YOUR_PACKAGE_MANAGER_URL"
ENV RSTUDIO_FORCE_NON_ZERO_EXIT_CODE 1
```
As especificações gerais a seguir se aplicam à imagem representada por uma versão RStudio da imagem.
**Executando a imagem**
`ENTRYPOINT`e `CMD` as instruções são substituídas para que a imagem seja executada como um RSession aplicativo.
**Interrompendo a imagem**
A API `DeleteApp` emite o equivalente a um comando `docker stop`. Outros processos no contêiner não receberão os SIGKILL/SIGTERM sinais.
**Sistema de arquivos**
Os diretórios `/opt/.sagemakerinternal` e `/opt/ml` são reservados. Qualquer dado nesses diretórios pode não estar visível em runtime.
**Dados do usuário**
Cada usuário em um domínio de SageMaker IA obtém um diretório de usuários em um volume compartilhado do Amazon Elastic File System na imagem. A localização do diretório do usuário atual no volume do Amazon Elastic File System é `/home/sagemaker-user`.
**Metadados**
Um arquivo de metadados está localizado em `/opt/ml/metadata/resource-metadata.json`. Nenhuma variável de ambiente adicional é incluída às variáveis definidas na imagem. Para obter mais informações, consulte [Obter metadados da aplicação](notebooks-run-and-manage-metadata.md#notebooks-run-and-manage-metadata-app).
**GPU**
Em uma instância de GPU, a imagem é executada com a opção `--gpus`. Somente o kit de ferramentas CUDA deve ser incluído na imagem, não os drivers da NVIDIA. Para obter mais informações, consulte o [Guia do usuário do NVIDIA](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/user-guide.html).
**Métricas e registro em log**
Os registros do RSession processo são enviados para a Amazon CloudWatch na conta do cliente. O nome do grupo de logs é `/aws/sagemaker/studio`. O nome do fluxo de logs é `$domainID/$userProfileName/RSession/$appName`.
**Tamanho da imagem**
O tamanho da imagem é limitado a 25 GB. Para ver o tamanho da sua imagem, execute `docker image ls`.
# Crie uma RStudio imagem personalizada
**Importante**
Políticas personalizadas do IAM que permitem que o Amazon SageMaker SageMaker Studio ou o Amazon Studio Classic criem SageMaker recursos da Amazon também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permitir que o Studio e o Studio Classic criem recursos, mas não permitisse a marcação, erros AccessDenied "" podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que dão permissões para criar SageMaker recursos já incluem permissões para adicionar tags ao criar esses recursos.
Este tópico descreve como você pode criar uma RStudio imagem personalizada usando o console SageMaker AI e AWS CLI o. Se você usar o AWS CLI, deverá executar as etapas em sua máquina local. As etapas a seguir não funcionam no Amazon SageMaker Studio Classic.
Quando você cria uma imagem, a SageMaker IA também cria uma versão inicial da imagem. A versão da imagem representa uma imagem de contêiner no [Registro de contêiner Amazon Elastic Container Registry (ECR)](https://console.aws.amazon.com/ecr/). A imagem do contêiner deve atender aos requisitos a serem usados em RStudio. Para obter mais informações, consulte [Especificações de RStudio imagem personalizadas](rstudio-byoi-specs.md).
Para obter informações sobre como testar sua imagem localmente e resolver problemas comuns, consulte o [repositório SageMaker Studio Custom Image Samples](https://github.com/aws-samples/sagemaker-studio-custom-image-samples/blob/main/DEVELOPMENT.md).
**Topics**
+ [Adicione uma imagem de SageMaker contêiner RStudio Docker compatível com IA ao Amazon ECR](#rstudio-byoi-sdk-add-container-image)
+ [Crie uma SageMaker imagem do console](#rstudio-byoi-create-console)
+ [Crie uma imagem a partir do AWS CLI](#rstudio-byoi-create-cli)
## Adicione uma imagem de SageMaker contêiner RStudio Docker compatível com IA ao Amazon ECR
Use as seguintes etapas para adicionar uma imagem de contêiner do Docker ao Amazon ECR:
+ Crie um repositório do Amazon ECR.
+ Autentique no Amazon ECR.
+ Crie uma imagem RStudio Docker SageMaker compatível com IA.
+ Empurre a imagem para o repositório do Amazon ECR.
**nota**
O repositório Amazon ECR deve estar no mesmo que seu Região da AWS domínio.
**Criar e adicionar uma imagem do Docker ao Amazon ECR**
1. Crie um repositório do Amazon ECR usando a AWS CLI. Para criar o repositório usando o console do Amazon ECR, consulte [Criação de um repositório](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html).
```
aws ecr create-repository \
--repository-name rstudio-custom \
--image-scanning-configuration scanOnPush=true
```
Resposta:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-2:acct-id:repository/rstudio-custom",
"registryId": "acct-id",
"repositoryName": "rstudio-custom",
"repositoryUri": "acct-id.dkr.ecr.us-east-2.amazonaws.com/rstudio-custom",
...
}
}
```
1. Autentique-se no Amazon ECR usando o URI do repositório retornado como resposta do comando `create-repository`. Certifique-se de que a aplicação Docker está em execução. Para obter mais informações, consulte [Autenticação de registro](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth).
```
aws ecr get-login-password | \
docker login --username AWS --password-stdin
```
Resposta:
```
Login Succeeded
```
1. Crie a imagem do Docker. Execute o seguinte comando no diretório que inclui seu Dockerfile:
```
docker build .
```
1. Marque sua imagem criada com uma tag exclusiva.
```
docker tag ":"
```
1. Empurre a imagem de contêiner para o repositório do Amazon ECR. Para obter mais informações, consulte [ImagePush](https://docs.docker.com/engine/api/v1.40/#operation/ImagePush)[Enviar uma imagem](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html).
```
docker push :
```
Resposta:
```
The push refers to repository [.dkr.ecr.us-east-2.amazonaws.com/rstudio-custom]
r: digest: size: 3066
```
## Crie uma SageMaker imagem do console
**Criar uma imagem**
1. Abra o console Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, escolha **Configurações do administrador**.
1. Em **Configurações do administrador**, escolha **Imagens**.
1. Na página **Imagens personalizadas**, escolha **Criar imagem**.
1. Em **Fonte da imagem**, insira o caminho do registro para a imagem de contêiner no Amazon ECR. O caminho é tem o seguinte formato:
` acct-id.dkr.ecr.region.amazonaws.com/repo-name[:tag] or [@digest] `
1. Escolha **Próximo**.
1. Em **Propriedades da imagem**, insira o seguinte:
+ Nome da imagem: O nome deve ser exclusivo para a sua conta Região da AWS atual.
+ (Opcional) Nome de exibição da imagem: O nome exibido na interface de usuário do domínio. Quando não fornecido, `Image name` é exibido.
+ (Opcional) Descrição: uma descrição da imagem.
+ Função do IAM — A função deve ter a [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)política anexada. Use a lista suspensa para escolher uma das seguintes opções:
+ Criar um novo perfil: Especifique quaisquer buckets adicionais do Amazon Simple Storage Service (Amazon S3) aos quais você deseja que os usuários dos cadernos tenham acesso. Se não quiser permitir acesso a buckets adicionais, escolha **Nenhum**.
SageMaker A IA atribui a `AmazonSageMakerFullAccess` política à função. A função permite que os usuários de seus cadernos tenham acesso aos buckets do S3 listados ao lado das marcas de verificação.
+ Insira um ARN do perfil do IAM personalizado: Insira o nome do recurso da Amazon (ARN) da perfil do IAM.
+ Uso da função existente: Escolha uma das suas funções existentes na lista.
+ (Opcional) Tags de imagem: Escolha **Adicionar nova tag**. É possível adicionar até 50 tags. As tags podem ser pesquisadas usando o console de SageMaker IA ou a `Search` API de SageMaker IA.
1. Em **Tipo de imagem**, selecione RStudio imagem.
1. Escolha **Enviar**.
A nova imagem é exibida na lista de **imagens personalizadas** e destacada brevemente. Depois que a imagem for criada com êxito, você poderá escolher o nome da imagem para ver suas propriedades ou escolher **Criar versão** para criar outra versão.
**Para criar outra versão da imagem**
1. Escolha **Criar versão** na mesma linha da imagem.
1. Em **Fonte da imagem**, insira o caminho do registro para a imagem do Amazon ECR. A imagem não deve ser a mesma usada em uma versão anterior da imagem de SageMaker IA.
Para usar a imagem personalizada em RStudio, você deve anexá-la ao seu domínio. Para obter mais informações, consulte [Anexar uma SageMaker imagem personalizada](rstudio-byoi-attach.md).
## Crie uma imagem a partir do AWS CLI
Esta seção mostra como criar uma SageMaker imagem personalizada da Amazon usando AWS CLI o.
Use as etapas a seguir para criar uma SageMaker imagem:
+ Crie uma `Image`.
+ Crie uma `ImageVersion`.
+ Criar um arquivo de configuração.
+ Crie uma `AppImageConfig`.
**Para criar as entidades SageMaker de imagem**
1. Crie uma SageMaker imagem. O ARN do perfil deve ter pelo menos a política `AmazonSageMakerFullAccessPolicy` anexada.
```
aws sagemaker create-image \
--image-name rstudio-custom-image \
--role-arn arn:aws:iam:::role/service-role/
```
Resposta:
```
{
"ImageArn": "arn:aws:sagemaker:us-east-2:acct-id:image/rstudio-custom-image"
}
```
1. Crie uma versão de SageMaker imagem a partir da imagem. Passe o valor de tag exclusivo que você escolheu ao enviar a imagem para o Amazon ECR.
```
aws sagemaker create-image-version \
--image-name rstudio-custom-image \
--base-image :
```
Resposta:
```
{
"ImageVersionArn": "arn:aws:sagemaker:us-east-2:acct-id:image-version/rstudio-image/1"
}
```
1. Verifique se a versão da imagem foi criada com sucesso.
```
aws sagemaker describe-image-version \
--image-name rstudio-custom-image \
--version 1
```
Resposta:
```
{
"ImageVersionArn": "arn:aws:sagemaker:us-east-2:acct-id:image-version/rstudio-custom-image/1",
"ImageVersionStatus": "CREATED"
}
```
**nota**
Se a resposta for `"ImageVersionStatus": "CREATED_FAILED"`, ela também incluirá o motivo da falha. Um problema de permissão é uma causa comum de falha. Você também pode verificar seus Amazon CloudWatch Logs. O nome do grupo de logs é `/aws/sagemaker/studio`. O nome do fluxo de logs é `$domainID/$userProfileName/KernelGateway/$appName`.
1. Crie um arquivo de configuração denominado `app-image-config-input.json`. A configuração da imagem do aplicativo é usada para configurar a execução de uma SageMaker imagem como um aplicativo Kernel Gateway.
```
{
"AppImageConfigName": "rstudio-custom-config"
}
```
1. Crie o AppImageConfig usando o arquivo que você criou na etapa anterior.
```
aws sagemaker create-app-image-config \
--cli-input-json file://app-image-config-input.json
```
Resposta:
```
{
"AppImageConfigArn": "arn:aws:sagemaker:us-east-2:acct-id:app-image-config/r-image-config"
}
```
# Anexar uma SageMaker imagem personalizada
**Importante**
Políticas personalizadas do IAM que permitem que o Amazon SageMaker SageMaker Studio ou o Amazon Studio Classic criem SageMaker recursos da Amazon também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permitir que o Studio e o Studio Classic criem recursos, mas não permitisse a marcação, erros AccessDenied "" podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que dão permissões para criar SageMaker recursos já incluem permissões para adicionar tags ao criar esses recursos.
Este guia mostra como anexar uma RStudio imagem personalizada ao seu domínio Amazon SageMaker AI usando o console de SageMaker IA ou o AWS Command Line Interface (AWS CLI).
Para usar uma SageMaker imagem personalizada, você deve anexar uma RStudio imagem personalizada ao seu domínio. Quando você anexa uma versão de imagem, ela aparece no RStudio Launcher e está disponível na lista suspensa **Selecionar imagem**. Você usa o menu suspenso para alterar a imagem usada por. RStudio
Há um limite para o número de versões de imagens que você pode anexar. Depois de atingir o limite, você deve primeiro separar uma versão para poder anexar uma versão diferente da imagem.
**Topics**
+ [Anexe uma versão da imagem ao seu domínio usando o console](#rstudio-byoi-attach-console)
+ [Anexe uma versão de imagem existente ao seu domínio usando o AWS CLI](#rstudio-byoi-attach-cli)
## Anexe uma versão da imagem ao seu domínio usando o console
Você pode anexar uma versão de SageMaker imagem personalizada ao seu domínio usando o painel de controle do console SageMaker AI. Você também pode criar uma SageMaker imagem personalizada e uma versão da imagem e, em seguida, anexar essa versão ao seu domínio.
**Para anexar uma imagem existente**
1. Abra o console Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, escolha **Configurações do administrador**.
1. Em **Configurações do administrador**, escolha **Domínios**.
1. Selecione o domínio desejado.
1. Escolha **Ambiente**.
1. Em **Imagens do Custom SageMaker Studio Classic anexadas ao domínio**, escolha **Anexar imagem**.
1. Em **Fonte da imagem**, escolha **Imagem existente** ou **Nova imagem**.
Se você selecionar **Imagem existente**, escolha uma imagem na loja de SageMaker imagens da Amazon.
Se você selecionar **Nova imagem**, forneça o caminho de registro do Amazon ECR para sua imagem do Docker. O caminho deve estar no mesmo Região da AWS que o domínio. O repositório Amazon ECR deve estar na mesma conta do seu domínio, ou as permissões entre contas para SageMaker IA devem estar habilitadas.
1. Escolha uma imagem existente na lista.
1. Escolha uma versão da imagem na lista.
1. Escolha **Próximo**.
1. Insira valores para **Nome da imagem**, **Nome de exibição da imagem** e **Descrição**.
1. Escolha o Perfil do IAM. Para obter mais informações, consulte [Crie uma RStudio imagem personalizada](rstudio-byoi-create.md).
1. (Opcional) Adicione tags à imagem.
1. (Opcional) Escolha **Adicionar nova tag** e, em seguida, adicione uma tag de configuração.
1. Em **Tipo de imagem**, selecione **RStudioImagem**.
1. Selecione **Enviar**.
Aguarde até que a versão da imagem seja anexada ao domínio. Depois que a versão é anexada, ela aparece na lista de **imagens personalizadas** e fica brevemente em destaque.
## Anexe uma versão de imagem existente ao seu domínio usando o AWS CLI
Dois métodos são apresentados para anexar a versão da imagem ao seu domínio usando a AWS CLI. No primeiro método, você cria um novo domínio com a versão anexada. Esse método é mais simples, mas você deve especificar as informações e a função de execução da Amazon Virtual Private Cloud (Amazon VPC) necessárias para criar o domínio.
Se você já se integrou ao domínio, pode usar o segundo método para anexar a versão da imagem ao seu domínio atual. Nesse caso, você não precisa especificar as informações e a função de execução do Amazon VPC. Depois de anexar a versão, exclua todos os aplicativos em seu domínio e RStudio reinicie.
### Anexar a SageMaker imagem a um novo domínio
Para usar esse método, você deve especificar uma função de execução que tenha a [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)política anexada.
Use as etapas a seguir para criar o domínio e anexar a imagem de SageMaker IA personalizada:
+ Obtenha sua VPC ID e sub-rede padrão. IDs
+ Crie o arquivo de configuração para o domínio, que especifica a imagem.
+ Crie um domínio com o arquivo de configuração.
**Para adicionar a SageMaker imagem personalizada ao seu domínio**
1. Obtenha seu ID de VPC padrão.
```
aws ec2 describe-vpcs \
--filters Name=isDefault,Values=true \
--query "Vpcs[0].VpcId" --output text
```
Resposta:
```
vpc-xxxxxxxx
```
1. Obtenha sua sub-rede padrão IDs usando o ID da VPC da etapa anterior.
```
aws ec2 describe-subnets \
--filters Name=vpc-id,Values= \
--query "Subnets[*].SubnetId" --output json
```
Resposta:
```
[
"subnet-b55171dd",
"subnet-8a5f99c6",
"subnet-e88d1392"
]
```
1. Crie um arquivo de configuração denominado `create-domain-input.json`. Insira o ID da VPC, a sub-rede IDs e `ImageName` as etapas `AppImageConfigName` anteriores. Como o `ImageVersionNumber` não está especificado, a versão mais recente da imagem é usada, que é a única versão nesse caso. A função de execução deve atender aos requisitos em [Concluir os pré-requisitos](rstudio-byoi-prerequisites.md).
```
{
"DomainName": "domain-with-custom-r-image",
"VpcId": "",
"SubnetIds": [
""
],
"DomainSettings": {
"RStudioServerProDomainSettings": {
"DomainExecutionRoleArn": ""
}
},
"DefaultUserSettings": {
"ExecutionRole": "",
"RSessionAppSettings": {
"CustomImages": [
{
"AppImageConfigName": "rstudio-custom-config",
"ImageName": "rstudio-custom-image"
}
]
}
},
"AuthMode": "IAM"
}
```
1. Crie o domínio com a SageMaker imagem personalizada anexada.
```
aws sagemaker create-domain \
--cli-input-json file://create-domain-input.json
```
Resposta:
```
{
"DomainArn": "arn:aws:sagemaker:region:acct-id:domain/domain-id",
"Url": "https://domain-id.studio.region.sagemaker.aws/..."
}
```
### Anexar a SageMaker imagem a um domínio existente
Este método pressupõe que você já esteja integrado ao domínio. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md).
**nota**
Você deve excluir todas as aplicações no seu domínio para atualizar o domínio com a nova versão de imagem. Para obter informações sobre como excluir esses aplicações, consulte [Excluir um domínio da Amazon SageMaker AI](gs-studio-delete-domain.md).
Use as etapas a seguir para adicionar a SageMaker imagem ao seu domínio atual.
+ Obtenha o seu no console `DomainID` de SageMaker IA.
+ Use o `DomainID` para obter o `DefaultUserSettings` para o domínio.
+ Adicione o `ImageName` e `AppImageConfig` como uma `CustomImage` ao `DefaultUserSettings`.
+ Atualize seu domínio para incluir a imagem personalizada.
**Para adicionar a SageMaker imagem personalizada ao seu domínio**
1. Abra o console Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, escolha **Configurações do administrador**.
1. Em **Configurações do administrador**, escolha **Domínios**.
1. Selecione o domínio desejado.
1. Escolha **Configurações de domínio**.
1. Em **Configurações gerais**, encontre o **ID do domínio**. O ID está no seguinte formato: `d-xxxxxxxxxxxx`.
1. Use o ID do domínio para obter a descrição do domínio.
```
aws sagemaker describe-domain \
--domain-id
```
Resposta:
```
{
"DomainId": "d-xxxxxxxxxxxx",
"DefaultUserSettings": {
"KernelGatewayAppSettings": {
"CustomImages": [
],
...
}
}
}
```
1. Salve a seção `DefaultUserSettings` da resposta em um arquivo chamado `update-domain-input.json`.
1. Insira o `ImageName` e o `AppImageConfigName` das etapas anteriores como uma imagem personalizada. Como o `ImageVersionNumber` não está especificado, a versão mais recente da imagem é usada, que é a única versão nesse caso.
```
{
"DefaultUserSettings": {
"RSessionAppSettings": {
"CustomImages": [
{
"ImageName": "rstudio-custom-image",
"AppImageConfigName": "rstudio-custom-config"
}
]
}
}
}
```
1. Use o ID do domínio e o arquivo de configurações padrão do usuário para atualizar seu domínio.
```
aws sagemaker update-domain \
--domain-id \
--cli-input-json file://update-domain-input.json
```
Resposta:
```
{
"DomainArn": "arn:aws:sagemaker:region:acct-id:domain/domain-id"
}
```
1. Exclua a aplicação do `RStudioServerPro`. Você deve reiniciar o aplicativo de `RStudioServerPro` domínio compartilhado para a interface do usuário do RStudio Launcher para obter as alterações mais recentes.
```
aws sagemaker delete-app \
--domain-id --user-profile-name domain-shared \
--app-type RStudioServerPro --app-name default
```
1. Para criar um nova aplicação `RStudioServerPro`. Você deve criar esse aplicação usando o AWS CLI.
```
aws sagemaker create-app \
--domain-id --user-profile-name domain-shared \
--app-type RStudioServerPro --app-name default
```
# Inicie uma SageMaker imagem personalizada no RStudio
Você pode usar sua imagem personalizada ao iniciar um RStudio aplicativo a partir do console. Depois de criar sua SageMaker imagem personalizada e anexá-la ao seu domínio, a imagem aparece na caixa de diálogo do seletor de imagens do RStudio Launcher. Para iniciar um novo RStudio aplicativo, siga as etapas [Inicie RSessions a partir do RStudio Launcher](rstudio-launcher.md) e selecione sua imagem personalizada conforme mostrado na imagem a seguir.
![\[Captura de tela do RStudio lançador com menu suspenso de imagens.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/rstudio-launcher-custom.png)
# Limpeza do recurso de imagem
Este guia mostra como limpar os recursos de RStudio imagem que você criou nas seções anteriores. Para excluir uma imagem, conclua as etapas a seguir usando o console SageMaker AI ou o AWS CLI, conforme mostrado neste guia.
+ Separe a imagem e as versões da imagem do seu domínio Amazon SageMaker AI.
+ Exclua a imagem, a versão da imagem e a configuração da imagem da aplicação.
Depois de concluir essas etapas, você pode excluir a imagem de contêiner e o repositório do Amazon ECR. Para obter mais informações sobre como excluir a imagem de contêiner e o repositório, consulte [Excluir um repositório](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-delete.html).
## Limpe os recursos do console de SageMaker IA
Quando você separa uma imagem de um domínio, todas as versões da imagem são separadas. Quando uma imagem é separada, todos os usuários do domínio perdem o acesso às versões da imagem.
**Para desassociar uma imagem**
1. Abra o console Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, escolha **Configurações do administrador**.
1. Em **Configurações do administrador**, escolha **Domínios**.
1. Selecione o domínio desejado.
1. Escolha **Ambiente**.
1. Em **Imagens personalizadas anexadas ao domínio**, escolha a imagem e escolha **Desassociar**.
1. (Opcional) Para excluir a imagem e todas as versões do SageMaker AI, selecione **Também excluir as imagens selecionadas...** . Isso não exclui as imagens associadas do Amazon ECR.
1. Escolha **Desassociar**.
## Limpe os recursos do AWS CLI
**Para limpar os recursos**
1. Separe a imagem e as versões da imagem do seu domínio passando uma lista vazia de imagens personalizadas para o domínio. Abra o arquivo `update-domain-input.json` que você criou em [Anexe a SageMaker imagem ao seu domínio atual](studio-byoi-attach.md#studio-byoi-sdk-attach-current-domain).
1. Exclua as imagens personalizadas `RSessionAppSettings` e salve o arquivo. Não modifique as imagens personalizadas `KernelGatewayAppSettings`.
```
{
"DomainId": "d-xxxxxxxxxxxx",
"DefaultUserSettings": {
"KernelGatewayAppSettings": {
"CustomImages": [
],
...
},
"RSessionAppSettings": {
"CustomImages": [
],
"DefaultResourceSpec": {
}
...
}
}
}
```
1. Use o ID do domínio e o arquivo de configurações padrão do usuário para atualizar seu domínio.
```
aws sagemaker update-domain \
--domain-id \
--cli-input-json file://update-domain-input.json
```
Resposta:
```
{
"DomainArn": "arn:aws:sagemaker:us-east-2:acct-id:domain/d-xxxxxxxxxxxx"
}
```
1. Exclua a configuração da imagem da aplicação.
```
aws sagemaker delete-app-image-config \
--app-image-config-name rstudio-image-config
```
1. Exclua a SageMaker imagem, o que também exclui todas as versões da imagem. As imagens de contêiner no Amazon ECR que são representadas pelas versões da imagem não são excluídas.
```
aws sagemaker delete-image \
--image-name rstudio-image
```