Fórmula para utilizar su propio contenedor

En esta sección, te ofrecemos una guía paso a paso sobre lo que necesita para bring your own container (BYOC) en los trabajos híbridos de Braket: los scripts, los archivos y los pasos para combinarlos y empezar a trabajar con sus imágenes de Docker personalizadas. Las fórmulas para dos casos comunes:

Definir el script de entrada de contenedor es más complejo en el caso 2.

Cuando Braket ejecuta su trabajo híbrido, inicia el número y tipo de instancias de Amazon EC2 solicitados y, a continuación, ejecuta la imagen de Docker especificada por la entrada de URI de imagen en la creación del trabajo. Al utilizar la característica BYOC, debe especificar un URI de imagen alojado en un repositorio privado de Amazon ECR al que tenga acceso de lectura. Los trabajos híbridos de Braket utilizan esa imagen personalizada para ejecutar el trabajo.

Los componentes específicos que necesita para crear una imagen de Docker que se pueda utilizar con trabajos híbridos. Si no está familiarizado con la escritura y la creación de Dockerfiles, consulte la documentación de Dockerfile y la documentación de Amazon ECR CLI.

Una imagen base para su Dockerfile

Si utiliza Python y desea instalar software además del que se proporciona en los contenedores de Braket, una opción para la imagen base es una de las imágenes de contenedor de Braket, alojadas en nuestro repositorio de GitHub y en Amazon ECR. Tendrá que autenticarse en Amazon ECR para extraer la imagen y construir sobre ella. Por ejemplo, la primera línea del archivo de Docker de BYOC podría ser: FROM [IMAGE_URI_HERE]

A continuación, rellene el resto del Dockerfile para instalar y configurar el software que desea añadir al contenedor. Las imágenes de Braket preconstruidas ya contienen el script de punto de entrada de contenedor adecuado, por lo que no tiene que preocuparse por incluirlo.

Si desea utilizar un lenguaje que no sea Python, como C++, Rust o Julia, o si desea crear una imagen para una arquitectura de CPU que no sea x86, como ARM, es posible que tenga que crear una imagen pública básica. Puede encontrar muchas de estas imágenes en la galería pública de Amazon Elastic Container Registry. Asegúrese de elegir una que sea adecuada para la arquitectura de la CPU y, si es necesario, para la GPU que desee utilizar.

(Opcional) Un script de punto de entrada de contenedor modificado

Para ejecutar código que no sea Python como parte de su trabajo híbrido, modifique el script de Python que define el punto de entrada del contenedor. Por ejemplo, el script de Python braket_container.py en el GitHub de Amazon Braket. Este es el script que utilizan las imágenes preconstruidas por Braket para ejecutar el script de algoritmo y establecer las variables de entorno adecuadas. El propio script del punto de entrada del contenedor debe estar en Python, pero puede lanzar scripts que no sean de Python. En el ejemplo preconstruido, puede ver que los scripts de algoritmos de Python se lanzan como un subproceso de Python o como un proceso completamente nuevo. Al modificar esta lógica, puede habilitar el script de punto de entrada para lanzar scripts de algoritmos que no sean de Python. Por ejemplo, puede modificar la función thekick_off_customer_script() para lanzar procesos de Rust dependientes del final de la extensión del archivo.

También puede elegir escribir un braket_container.py completamente nuevo. Debería copiar los datos de entrada, los archivos fuente y otros archivos necesarios de Amazon S3 en el contenedor y definir las variables de entorno adecuadas.

Instalación del software y el script de contenedor necesarios con Dockerfile

Si ha creado un script de contenedor modificado en el paso anterior, deberá copiarlo en el contenedor y definir la variable de entorno SAGEMAKER_PROGRAM como braket_container.py, o como haya llamado al script del nuevo punto de entrada del contenedor.

El siguiente es un ejemplo de un Dockerfile que le permite usar Julia en instancias de trabajos 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

En este ejemplo, se descargan y ejecutan los scripts proporcionados por AWS para garantizar la conformidad con todas las licencias de código abierto pertinentes. Por ejemplo, atribuyendo correctamente cualquier código instalado que se rija por una MIT license.

Si necesita incluir código no público, por ejemplo, código alojado en un repositorio privado de GitHub o GitLab, no incruste claves SSH en la imagen de Docker para acceder. En su lugar, utilice Docker Compose en la creación para permitir el acceso de Docker a SSH en la máquina host en la que está integrado. Para obtener más información, consulte la guía Uso seguro de claves SSH en Docker para acceder a repositorios privados de GitHub.

Cómo crear y subir su imagen de Docker

Una vez definidoDockerfile correctamente, ya puede seguir los pasos para crear un repositorio privado de Amazon ECR, si aún no existe. También puede crear, etiquetar y cargar su imagen de contenedor en el repositorio.

Ya puede crear, etiquetar y enviar la imagen. Consulte la documentación de compilación de Docker para obtener una explicación completa de las opciones para docker build y algunos ejemplos.

Para el archivo de muestra definido anteriormente, puede ejecutar lo siguiente:

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

Asignación de los permisos de Amazon ECR adecuados

Las imágenes de Braket Hybrid Jobs Docker deben estar alojadas en repositorios privados de Amazon ECR. De forma predeterminada, un repositorio privado de Amazon ECR no proporciona acceso de lectura al Braket Hybrid Jobs IAM role ni a ningún otro usuario que quiera usar su imagen, como un colaborador o un estudiante. Debe establecer una política de repositorio para conceder los permisos adecuados. En general, conceda permiso únicamente a los usuarios y roles de IAM específicos a los que quiera que accedan a sus imágenes, en lugar de permitir que cualquier persona con el image URI acceda.