Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Ricetta per portare il proprio contenitore

In questa sezione, forniamo una step-by-step guida su ciò che ti servirà bring your own container (BYOC) per Braket Hybrid Jobs: gli script, i file e i passaggi per combinarli per iniziare a utilizzare le tue immagini personalizzate. Docker Forniamo ricette per due casi comuni:

La definizione dello script di immissione del contenitore è più complessa nel caso 2.

Quando Braket esegue il tuo Hybrid Job, avvia il numero e il tipo richiesti di EC2 istanze Amazon, quindi esegue l'Dockerimmagine specificata dall'URI dell'immagine input per la creazione del lavoro su di esse. Quando utilizzi la funzionalità BYOC, specifichi un URI di immagine ospitato in un repository Amazon ECR privato a cui hai accesso in lettura. Braket Hybrid Jobs utilizza quell'immagine personalizzata per eseguire il lavoro.

I componenti specifici necessari per creare un'Dockerimmagine che può essere utilizzata con Hybrid Jobs. Se non hai familiarità con la scrittura e la creazioneDockerfiles, ti suggeriamo di fare riferimento alla documentazione di Dockerfile e alla Amazon ECR CLIdocumentazione, se necessario, mentre leggi queste istruzioni.

Un'immagine di base per il tuo Dockerfile

Se utilizzi Python e desideri installare software in aggiunta a quanto fornito nei contenitori forniti da Braket, un'opzione per un'immagine di base è una delle immagini del contenitore Braket, ospitate nel nostro GitHub repository e su Amazon ECR. Dovrai autenticarti su Amazon ECR per estrarre l'immagine e crearla su di essa. Ad esempio, la prima riga del tuo file BYOC potrebbe essereDocker: FROM [IMAGE_URI_HERE]

Quindi, compila il resto Dockerfile per installare e configurare il software che desideri aggiungere al contenitore. Le immagini Braket predefinite conterranno già lo script del punto di ingresso del contenitore appropriato, quindi non devi preoccuparti di includerlo.

Se vuoi usare un linguaggio non Python, come C++, Rust o Julia, o se vuoi creare un'immagine per un'architettura CPU non x86, come ARM, potresti dover creare su un'immagine pubblica barebone. Puoi trovare molte di queste immagini nella galleria pubblica di Amazon Elastic Container Registry. Assicurati di sceglierne una adatta all'architettura della CPU e, se necessario, alla GPU che desideri utilizzare.

(Facoltativo) Uno script modificato per il punto di ingresso del contenitore

Per eseguire codice non Python come parte del tuo lavoro ibrido, dovrai modificare lo script Python che definisce il punto di ingresso del contenitore. Ad esempio, lo script braket_container.py python su Amazon Braket Github. Questo è lo script che le immagini precreate da Braket utilizzano per avviare lo script dell'algoritmo e impostare le variabili di ambiente appropriate. Lo script del punto di ingresso del contenitore stesso deve essere in Python, ma può avviare script non Python. Nell'esempio predefinito, puoi vedere che gli script degli algoritmi Python vengono avviati come sottoprocesso Python o come processo completamente nuovo. Modificando questa logica, è possibile abilitare lo script del punto di ingresso per avviare script di algoritmi non Python. Ad esempio, è possibile modificare la thekick_off_customer_script()funzione per avviare i processi Rust in base alla fine dell'estensione del file.

Puoi anche scegliere di scriverne uno completamente nuovobraket_container.py. Dovrebbe copiare i dati di input, gli archivi di origine e altri file necessari da Amazon S3 nel contenitore e definire le variabili di ambiente appropriate.

Installa il software e lo script del contenitore necessari con Dockerfile

Se hai creato uno script contenitore modificato nel passaggio precedente, dovrai copiarlo nel contenitore e definire la variabile di ambiente o il nome che hai dato SAGEMAKER_PROGRAM al braket_container.py nuovo script del punto di ingresso del contenitore.

Di seguito è riportato un esempio Dockerfile che consente di utilizzare Julia su istanze Jobs accelerate da 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

Questo esempio scarica ed esegue gli script forniti da per garantire la conformità con tutte le licenze AWS Open-Source pertinenti. Ad esempio, attribuendo correttamente qualsiasi codice installato governato da un. MIT license

Se devi includere codice non pubblico, ad esempio codice ospitato in un GitLab archivio GitHub o in un archivio privato, non incorporare le chiavi SSH nell'immagine per accedervi. Docker Utilizza invece Docker Compose when you build per consentire l'accesso Docker a SSH sulla macchina host su cui è costruito. Per ulteriori informazioni, consulta la guida Uso sicuro delle chiavi SSH in Docker per accedere ai repository privati di Github.

DockerCreazione e caricamento della tua immagine

Una volta definito correttamenteDockerfile, sei pronto a seguire i passaggi per creare un repository Amazon ECR privato, se non ne esiste già uno. Puoi anche creare, etichettare e caricare l'immagine del contenitore nel repository.

Sei pronto per creare, etichettare e inserire l'immagine. Consulta la documentazione della build di Docker per una spiegazione completa delle opzioni docker build e alcuni esempi.

Per il file di esempio sopra definito, puoi eseguire:

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

Assegnazione delle autorizzazioni Amazon ECR appropriate

Braket Hybrid Jobs Dockerle immagini devono essere ospitate in repository privati di Amazon ECR. Per impostazione predefinita, un repository Amazon ECR privato non fornisce l'accesso in lettura a Braket Hybrid Jobs IAM role o ad altri utenti che desiderano utilizzare la tua immagine, ad esempio un collaboratore o uno studente. È necessario impostare una politica di repository per concedere le autorizzazioni appropriate. In generale, concedi l'autorizzazione solo agli utenti e ai IAM ruoli specifici a cui desideri accedere alle tue immagini, anziché consentire a chiunque li possieda di image URI recuperarle.