Como trazer seu próprio contêiner

Nesta seção, fornecemos um guia passo a passo do que você precisa para bring your own container (BYOC) para o Braket Hybrid Jobs — os scripts, arquivos e etapas para combiná-los para começar a trabalhar com suas imagens Docker personalizadas. As 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 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 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 criarDockerfiles, consulte a documentação do Dockerfile e a documentação Amazon ECR CLI.

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 do GitHub e no Amazon ECR. Você precisará se autenticar no Amazon ECR 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++, 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. 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

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. 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 função thekick_off_customer_script() 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

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 pela 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 repositório privado do GitHub ou do GitLab, não incorpore chaves SSH na imagem Docker 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.

Criando e enviando sua imagem Docker

Com um repositório Amazon ECR devidamente definidoDockerfile, agora você está pronto para seguir as etapas para criar um repositório privado do Amazon ECR, 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 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 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.