

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á.

# Como trazer seu próprio contêiner
<a name="bring-own-container-recipe"></a>

Nesta seção, fornecemos um step-by-step guia do que você precisa fazer bring your own container (BYOC) para Braket Hybrid Jobs — os scripts, arquivos e etapas para combiná-los para começar a trabalhar com suas imagens personalizadasDocker. As receitas para dois casos comuns:

1. Instale software adicional em uma imagem Docker e use somente scripts de algoritmo Python em seus trabalhos.

1. Use scripts de algoritmo escritos em uma linguagem não Python com trabalhos híbridos ou uma arquitetura de CPU além de x86.

Definir o *script de entrada do contêiner* é mais complexo para o caso 2.

Quando o Braket executa seu Hybrid Job, ele inicia o número e o tipo solicitados de instâncias do Amazon EC2 e, em seguida, Docker executa a imagem especificada pela entrada do URI da imagem para a criação do trabalho nelas. Ao usar o recurso BYOC, você especifica um URI de imagem hospedado em um [repositório privado do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) ao qual você tem acesso de leitura. O Braket Hybrid Jobs usa essa imagem personalizada para executar o trabalho.

Os componentes específicos necessários para criar uma imagem Docker que possa ser usada com trabalhos híbridos. Se você não estiver familiarizado com escrever e criar`Dockerfiles`, consulte a [documentação do Dockerfile](https://docs.docker.com/reference/dockerfile/) e a [documentação Amazon ECR CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html).

**Topics**
+ [Uma imagem base para seu Dockerfile](#base-image-dockerfile)
+ [(Opcional) Um script de ponto de entrada de contêiner modificado](#modified-container-entry-point)
+ [Instale o software e o script de contêiner necessários com `Dockerfile`](#install-docketfile)

## Uma imagem base para seu Dockerfile
<a name="base-image-dockerfile"></a>

[Se você estiver usando Python e quiser instalar software além do que é fornecido nos contêineres fornecidos pelo Braket, uma opção para uma imagem base é uma das imagens do contêiner do Braket, hospedada em nosso GitHub repositório e no Amazon ECR.](https://github.com/amazon-braket/amazon-braket-containers) Você precisará se [autenticar no Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) para extrair a imagem e criar em cima dela. Por exemplo, a primeira linha do seu arquivo Docker BYOC pode ser: `FROM [IMAGE_URI_HERE]`

Em seguida, preencha o restante do Dockerfile para instalar e configurar o software que você deseja adicionar ao contêiner. As imagens pré-criadas do Braket já conterão o script de ponto de entrada do contêiner apropriado, então você não precisa se preocupar em incluí-lo.

Se você quiser usar uma linguagem não Python, como C\$1\$1, Rust ou Julia, ou se quiser criar uma imagem para uma arquitetura de CPU não x86, como ARM, talvez seja necessário criar com base em uma imagem pública básica. Você pode encontrar muitas dessas imagens na [Galeria Pública do Amazon Elastic Container Registry](https://gallery.ecr.aws/). Certifique-se de escolher uma que seja apropriada para a arquitetura da CPU e, se necessário, para a GPU que você deseja usar.

## (Opcional) Um script de ponto de entrada de contêiner modificado
<a name="modified-container-entry-point"></a>

**nota**  
Se você só estiver adicionando mais software a uma imagem de Braket pré-criada, ignore esta seção.

Para executar código não Python como parte de seu trabalho híbrido, modifique o script Python que define o ponto de entrada do contêiner. Por exemplo, o [script `braket_container.py` python no Amazon Braket Github](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py). Esse é o script que as imagens pré-construídas pelo Braket usam para iniciar seu script de algoritmo e definir as variáveis de ambiente apropriadas. O script de ponto de entrada do contêiner em si **deve** estar em Python, mas pode iniciar scripts que não sejam Python. No exemplo pré-construído, você pode ver que os scripts do algoritmo Python são lançados como um [subprocesso do Python](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L274) ou [como um processo totalmente novo.](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L257) Ao modificar essa lógica, você pode habilitar o script de ponto de entrada para iniciar scripts de algoritmo não Python. Por exemplo, você pode modificar a [função `thekick_off_customer_script()`](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L139) para iniciar processos Rust dependendo do final da extensão do arquivo.

Você também pode escrever um `braket_container.py` completamente novo. Ele deve copiar dados de entrada, arquivos de origem e outros arquivos necessários do Amazon S3 para o contêiner e definir as variáveis de ambiente apropriadas.

## Instale o software e o script de contêiner necessários com `Dockerfile`
<a name="install-docketfile"></a>

**nota**  
Se você usar uma imagem Braket pré-criada como imagem Docker base, o script do contêiner já estará presente.

Se você criou um script de contêiner modificado na etapa anterior, precisará copiá-lo para o contêiner **e** definir a variável de ambiente de `SAGEMAKER_PROGRAM` para `braket_container.py`, ou para o nome que você deu ao seu novo script de ponto de entrada do contêiner.

Veja a seguir um exemplo de um `Dockerfile` que permite que você use Julia em instâncias de Jobs aceleradas por GPU:

```
FROM nvidia/cuda:12.2.0-devel-ubuntu22.04

    
 ARG DEBIAN_FRONTEND=noninteractive
 ARG JULIA_RELEASE=1.8
 ARG JULIA_VERSION=1.8.3


 ARG PYTHON=python3.11 
 ARG PYTHON_PIP=python3-pip
 ARG PIP=pip


 ARG JULIA_URL = https://julialang-s3.julialang.org/bin/linux/x64/${JULIA_RELEASE}/
 ARG TAR_NAME = julia-${JULIA_VERSION}-linux-x86_64.tar.gz


 ARG PYTHON_PKGS = # list your Python packages and versions here


 RUN curl -s -L ${JULIA_URL}/${TAR_NAME} | tar -C /usr/local -x -z --strip-components=1 -f -


 RUN apt-get update \

    && apt-get install -y --no-install-recommends \

    build-essential \

    tzdata \

    openssh-client \

    openssh-server \

    ca-certificates \

    curl \

    git \

    libtemplate-perl \

    libssl1.1 \

    openssl \

    unzip \ 

    wget \

    zlib1g-dev \

    ${PYTHON_PIP} \

    ${PYTHON}-dev \




 RUN ${PIP} install --no-cache --upgrade ${PYTHON_PKGS}


 RUN ${PIP} install --no-cache --upgrade sagemaker-training==4.1.3


 # Add EFA and SMDDP to LD library path
 ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
 ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH


 # Julia specific installation instructions
 COPY Project.toml /usr/local/share/julia/environments/v${JULIA_RELEASE}/
 RUN JULIA_DEPOT_PATH=/usr/local/share/julia \

    julia -e 'using Pkg; Pkg.instantiate(); Pkg.API.precompile()'
 # generate the device runtime library for all known and supported devices
 RUN JULIA_DEPOT_PATH=/usr/local/share/julia \

    julia -e 'using CUDA; CUDA.precompile_runtime()'


 # Open source compliance scripts
 RUN HOME_DIR=/root \

 && curl -o ${HOME_DIR}/oss_compliance.zip https://aws-dlinfra-utilities.s3.amazonaws.com/oss_compliance.zip \

 && unzip ${HOME_DIR}/oss_compliance.zip -d ${HOME_DIR}/ \

 && cp ${HOME_DIR}/oss_compliance/test/testOSSCompliance /usr/local/bin/testOSSCompliance \

 && chmod +x /usr/local/bin/testOSSCompliance \

 && chmod +x ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh \

 && ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh ${HOME_DIR} ${PYTHON} \

 && rm -rf ${HOME_DIR}/oss_compliance*


 # Copying the container entry point script
 COPY braket_container.py /opt/ml/code/braket_container.py
 ENV SAGEMAKER_PROGRAM braket_container.py
```

Este exemplo baixa e executa scripts fornecidos por AWS para garantir a conformidade com todas as licenças de código aberto relevantes. Por exemplo, atribuindo adequadamente qualquer código instalado governado por um MIT license.

Se você precisar incluir código não público, por exemplo, código hospedado em um GitLab repositório GitHub ou privado, **não** incorpore chaves SSH na Docker imagem para acessá-la. Em vez disso, use o Docker Compose ao criar para permitir ao Docker o acesso ao SSH na máquina host em que ele foi criado. Para obter mais informações, consulte o guia [Como usar chaves SSH com segurança no Docker para acessar repositórios privados do Github](https://www.fastruby.io/blog/docker/docker-ssh-keys.html).

**Criando e enviando sua imagem Docker**

Com um repositório Amazon ECR devidamente definido`Dockerfile`, agora você está pronto para seguir as etapas para [criar um repositório privado do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html), caso ainda não exista um. Você também pode criar, marcar e carregar sua imagem de contêiner no repositório.

Você está pronto para criar, marcar e enviar a imagem. Consulte a [documentação de compilação do Docker](https://docs.docker.com/reference/cli/docker/buildx/build/) para obter uma explicação completa das opções para o `docker build` e alguns exemplos.

Para o arquivo de amostra definido acima, você pode executar:

```
aws ecr get-login-password --region ${your_region} | docker login --username AWS --password-stdin ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com
 docker build -t braket-julia .
 docker tag braket-julia:latest ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest
 docker push ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest
```

**Atribuição de permissões apropriadas do Amazon ECR**

As imagens do Braket Hybrid Jobs Docker devem ser hospedadas em repositórios privados do Amazon ECR. Por padrão, um repositório privado do Amazon ECR **não** fornece acesso de leitura ao Braket Hybrid Jobs IAM role ou a nenhum outro usuário que queira usar sua imagem, como um colaborador ou estudante. Você precisa [definir uma política de repositório](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) para conceder as permissões apropriadas. Em geral, dê permissão apenas aos usuários e perfis do IAM específicos aos quais você deseja acessar suas imagens, em vez de permitir que qualquer pessoa com a image URI as extraia.