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

Receita para trazer seu próprio recipiente

Nesta seção, fornecemos um step-by-step guia do que você precisará bring your own container (BYOC) para Braket Hybrid Jobs — os scripts, arquivos e etapas para combiná-los a fim de começar a trabalhar com seus aplicativos personalizados Docker imagens. Fornecemos receitas para dois casos comuns:

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 de EC2 instâncias da Amazon solicitados e, em seguida, executa o Docker imagem especificada pela URI entrada da imagem para a criação de empregos neles. Ao usar o BYOC recurso, você especifica uma imagem URI hospedada em um ECRrepositório privado da Amazon ao qual você tem acesso de leitura. O Braket Hybrid Jobs usa essa imagem personalizada para executar o trabalho.

Os componentes específicos que você precisa para criar um Docker imagem que pode ser usada com Hybrid Jobs. Se você não estiver familiarizado com escrever e criarDockerfiles, sugerimos que consulte a documentação do Dockerfile e a Amazon ECR CLI documentação conforme necessário enquanto você lê essas instruções.

Uma imagem base para seu Dockerfile

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 repositório e na Amazon. GitHub ECR Você precisará se autenticar na Amazon ECR para extrair a imagem e criar em cima dela. Por exemplo, a primeira linha do seu BYOC Docker o arquivo 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++, Rust ou Julia, ou se quiser criar uma imagem para uma CPU arquitetura não x86, talvez seja necessário criar em cima de uma imagem pública básica. ARM Você pode encontrar muitas dessas imagens na Galeria Pública do Amazon Elastic Container Registry. Certifique-se de escolher um que seja apropriado para a CPU arquitetura e, se necessário, o GPU que você deseja usar.

(Opcional) Um script de ponto de entrada de contêiner modificado

Para executar código não Python como parte de seu trabalho híbrido, você precisará modificar o script Python que define o ponto de entrada do contêiner. Por exemplo, o script braket_container.py python no Amazon Braket Github. 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 ou como um processo totalmente novo. 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 thekick_off_customer_script()função para iniciar processos Rust dependendo do final da extensão do arquivo.

Você também pode optar por escrever um texto completamente novobraket_container.py. 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

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

Veja a seguir um exemplo de uma Dockerfile que permite que você use Julia em instâncias GPU -accelerated Jobs:

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 SSH incorpore chaves no Docker imagem para acessá-la. Em vez disso, use Docker Compose quando você constrói para permitir Docker para acessar SSH na máquina host na qual ele foi construído. Para obter mais informações, consulte o guia Como usar SSH chaves com segurança no Docker para acessar repositórios privados do Github.

Construindo e enviando seu Docker imagem

Com uma definição adequadaDockerfile, agora você está pronto para seguir as etapas para criar um ECR repositório privado da Amazon, 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 para obter uma explicação completa das opções 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 da Amazon ECR

Braket Hybrid Jobs Docker as imagens devem ser hospedadas em ECR repositórios privados da Amazon. Por padrão, um ECR repositório privado da Amazon não fornece acesso de leitura ao Braket Hybrid Jobs IAM role ou para qualquer outro usuário que queira usar sua imagem, como um colaborador ou aluno. Você deve definir uma política de repositório para conceder as permissões apropriadas. Em geral, dê permissão apenas a esses usuários específicos e IAM funções nas quais você deseja acessar suas imagens, em vez de permitir que qualquer pessoa com o image URI para puxá-los.