Personalize contêineres com o serviço Databricks Container

O Databricks Container Services permite especificar uma Docker Image ao criar compute. Alguns exemplos de casos de uso incluem:

Personalização da biblioteca: você tem controle total sobre as bibliotecas do sistema que deseja instalar.
Ambiente de contêiner dourado: sua imagem do Docker é um ambiente bloqueado que nunca mudará.
Integração Docker CI/CD: você pode integrar Databricks com seus pipelines Docker CI/CD.

O senhor também pode usar o Docker Image para criar ambientes personalizados de aprendizagem profunda em compute com dispositivos de GPU. Para obter informações adicionais sobre o uso da GPU compute com o Databricks Container Services, consulte Databricks Container Services na GPU compute.

Para tarefas a serem executadas sempre que o contêiner for iniciado, use um script init.

Requisitos

Seu workspace do Databricks deve ter o Databricks Container Services habilitado.
Sua máquina deve estar rodando um daemon Docker recente (testado e que funcione com a versão Client/Server 18.03.0-ce) e o comando docker deve estar disponível em seu PATH.

Limitações

O Databricks Container Services não tem suporte na compute usando o modo de acesso compartilhado.
Databricks Runtime para Machine Learning não oferece suporte a Databricks Container Services.
Para acessar volumes em serviços de contêiner do Databricks, adicione a seguinte configuração ao computecampo de configuração do Spark do : spark.databricks.unityCatalog.volumes.enabled true.

O Databricks Container Services não é compatível com os tipos de instância do AWS Graviton.

Passo 1: Construa sua base

A Databricks recomenda que você crie sua base do Docker a partir de uma base que a Databricks construiu e testou. Também é possível construir sua base Docker do zero. Esta seção descreve as duas opções.

Opção 1. Use uma base construída pela Databricks

Este exemplo usa o 9.x tag para uma imagem que terá como alvo um compute com versão de tempo de execução Databricks Runtime 9.1 LTS e acima:

FROM databricksruntime/standard:9.x
...

Para especificar bibliotecas Python adicionais, como a versão mais recente de pandas e urllib, use a versão específica do contêiner de pip. Para o contêiner databricksruntime/standard:9.x, inclua o seguinte:

RUN /databricks/python3/bin/pip install pandas
RUN /databricks/python3/bin/pip install urllib3

Para o contêiner databricksruntime/standard:8.x ou mais baixo, inclua o seguinte:

RUN /databricks/conda/envs/dcs-minimal/bin/pip install pandas
RUN /databricks/conda/envs/dcs-minimal/bin/pip install urllib3

As imagens de base são hospedadas no Docker Hub em https://hub.docker.com/u/databricksruntime. Os Dockerfiles usados para gerar essas bases estão em https://github.com/databricks/containers.

Observação

As imagens hospedadas no Docker Hub com tags com o sufixo “-LTS” serão corrigidas. Todas as outras imagens são exemplos e não são corrigidas regularmente.

Observação

As imagens base databricksruntime/standard e databricksruntime/minimal não devem ser confundidas com os ambientes databricks-standard e databricks-minimal não relacionados incluídos no Databricks Runtime com Conda (Beta) não mais disponível.

Opção 2. Crie sua própria base do Docker

Você também pode criar sua base do Docker do zero. A imagem do Docker deve atender a estes requisitos:

JDK 8u191 como Java no sistema PATH
bash
iproute2 (ubuntu iproute)
coreutils (ubuntu coreutils)
procps (ubuntu procps)
sudo (ubuntu sudo)
Ubuntu Linux

Para construir sua própria imagem do zero, você deve criar o ambiente virtual. Você também deve incluir pacotes integrados ao compute do Databricks, como Python e R. Para começar, você pode usar a imagem base apropriada:

Para R: databricksruntime/rbase
Para Python: databricksruntime/python
Para a imagem mínima criada pelo Databricks: databricksruntime/minimal

Você também pode consultar o exemplo Dockerfiles no GitHub.

Observação

A Databricks recomenda o uso do Ubuntu Linux; no entanto, é possível usar o Alpine Linux. Para usar o Alpine Linux, você deve incluir estes arquivos:

Além disso, você deve configurar o Python, conforme mostrado neste Dockerfile de exemplo.

Aviso

Teste completamente a imagem do seu contêiner personalizado em uma compute do Databricks. Seu contêiner pode funcionar em uma máquina local ou de construção, mas quando seu contêiner é iniciado no Databricks, o lançamento da compute pode falhar, determinado recurso pode ser desabilitado ou seu contêiner pode parar de funcionar, mesmo silenciosamente. Na pior das hipóteses, isso pode corromper seus dados ou expô-los acidentalmente a terceiros.

Como lembrete, seu uso dos Databricks Container Services está sujeito aos Termos Específicos do Serviço.

passo 2: envie sua imagem base

Envie sua imagem de base personalizada para um registro do Docker. Este processo é suportado com os seguintes registros:

Docker Hub sem autenticação ou autenticação básica.
Amazon Elastic Container Registry (Amazon ECR) com IAM (com exceção dos serviços de nuvem comercial (C2S)).
Registro de contêiner do Azure com autenticação básica.

Outros registros do Docker que não suportam autenticação ou autenticação básica também devem funcionar.

Observação

Se você usar o Docker Hub para seu registro do Docker, verifique se os limites de taxa acomodam a quantidade de compute que você espera iniciar em um período de seis horas. Esses limites de taxas são diferentes para usuários anônimos, usuários autenticados sem inscrição paga e inscrição paga. Consulte a documentação do Docker para obter detalhes. Se esse limite for excedido, você receberá uma resposta “429 Too Many Requests”.

o passo 3: Inicie seu computador

Você pode iniciar sua compute usando a UI ou a API.

Inicie sua computação usando a IU

Na página Criar compute , especifique uma versão Databricks Runtime que dê suporte ao Databricks Container Services.
Em Opções avançadas, selecione a guia Docker.
Selecione Usar seu próprio contêiner do Docker.

No campo URL da imagem do Docker, insira sua imagem personalizada do Docker.

Exemplos de URL de imagem do Docker:

Registro	Formato da etiqueta
Docker Hub	`<organization>/<repository>:<tag>` (por exemplo: `databricksruntime/standard:latest`)
Amazon ECR	`<aws-account-id>.dkr.ecr.<region>.amazonaws.com/<repository>:<tag>`
Registro de contêiner do Azure	`<your-registry-name>.azurecr.io/<repository-name>:<tag>`

Selecione o tipo de autenticação.

Inicie sua computação usando a API

Gere um token de API.

Use a API Clusters para iniciar uma compute com sua base personalizada do Docker.

curl -X POST -H "Authorization: Bearer <token>" https://<databricks-instance>/api/2.0/clusters/create -d '{
  "cluster_name": "<cluster-name>",
  "num_workers": 0,
  "node_type_id": "i3.xlarge",
  "docker_image": {
    "url": "databricksruntime/standard:latest",
    "basic_auth": {
      "username": "<docker-registry-username>",
      "password": "<docker-registry-password>"
    }
  },
  "spark_version": "7.3.x-scala2.12",
  "aws_attributes": {
    "availability": "ON_DEMAND",
    "instance_profile_arn": "arn:aws:iam::<aws-account-number>:instance-profile/<iam-role-name>"
  }
}'

basic_auth Os requisitos dependem do tipo de imagem do Docker:

Para imagens públicas do Docker, não inclua o campo basic_auth.
Para imagens privadas do Docker, você deve incluir o campo basic_auth, usando um ID de entidade de serviço e senha como nome de usuário e senha.
Para o Azure Container Registry, você deve definir o campo basic_auth para a ID e a senha de uma entidade de serviço. Consulte a documentação de autenticação da entidade de serviço do registro de contêiner do Azure para obter informações sobre como criar a entidade de serviço.

Para imagens do Amazon ECR, não inclua o campo basic_auth . Você deve iniciar sua compute com um instance profile que inclua permissões para extrair Docker Image do repositório do Docker onde a imagem reside. Para fazer isso, siga os passos 3 e 4 do processo de configuração do acesso seguro aos buckets S3 usando instance profile.

Aqui está um exemplo de uma função do IAM com permissão para extrair qualquer imagem. O repositório é especificado por <arn-of-repository>.

 {
   "Version": "2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Action": [
           "ecr:GetAuthorizationToken"
       ],
     "Resource": "*"
   },
   {
     "Effect": "Allow",
     "Action": [
         "ecr:BatchCheckLayerAvailability",
         "ecr:GetDownloadUrlForLayer",
         "ecr:GetrepositoryPolicy",
         "ecr:DescribeRepositories",
         "ecr:ListImages",
         "ecr:DescribeImages",
         "ecr:BatchGetImage"
       ],
       "Resource": [ "<arn-of-repository>" ]
     }
   ]
 }

Se a imagem do Amazon ECR residir em uma da AWS diferente account da do Databricks,compute use uma política de repositório ECR além do compute instance profile para conceder compute acesso de . Aqui está um exemplo de uma política de repositório ECR. A IAM role assumida pelo do compute instance profile é especificada por <arn-of-IAM-role>.

{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "AllowCrossAccountPush",
    "Effect": "Allow",
    "Principal": {
      "AWS": "<arn-of-IAM-role>"
    },
    "Action": [
      "ecr:BatchCheckLayerAvailability",
      "ecr:BatchGetImage",
      "ecr:DescribeImages",
      "ecr:DescribeRepositories",
      "ecr:GetDownloadUrlForLayer",
      "ecr:GetrepositoryPolicy",
      "ecr:ListImages"
    ]
  }]
}

Use um script de inicialização

Os Databricks Container Services permitem que os clientes incluam init script no contêiner Docker. Na maioria dos casos, você deve evitar init script e, em vez disso, fazer personalizações diretamente por meio do Docker (usando o Dockerfile). Porém, certas tarefas devem ser executadas quando o contêiner for iniciado, e não quando o contêiner for construído. Use um init script para essas tarefas.

Por exemplo, suponha que você queira executar um daemon de segurança dentro de um contêiner personalizado. Instale e crie o daemon na imagem do Docker por meio do pipeline de criação de imagem. Em seguida, adicione um script de inicialização que inicia o daemon. Neste exemplo, o script de inicialização incluiria uma linha como systemctl start my-daemon.

Na API, você pode especificar init script como parte da especificação compute da seguinte maneira. Para mais informações, consulte a API Clusters.

"init_scripts": [
    {
        "file": {
            "destination": "file:/my/local/file.sh"
        }
    }
]

Para imagens do Databricks Container Services, você também pode armazenar init script no armazenamento clouds .

As etapas a seguir ocorrem quando você inicia uma compute que usa Databricks Container Services:

As VMs são adquiridas do provedor de nuvem.
A imagem personalizada do Docker é baixada do seu repositório.
O Databricks cria um contêiner Docker da imagem.
O código do Databricks Runtime é copiado para o contêiner do Docker.
O init script é executado. Consulte O que são init script?.

O Databricks ignora as primitivas Docker CMD e ENTRYPOINT.

Habilitar serviços de contêineres

Para utilizar contentores personalizados no seu compute, um administrador workspace deve ativar os Databricks Container Services.

Os administradores do workspace podem ativar o Databricks Container Service usando a API de configuração do workspace. Em um corpo de solicitação JSON, especifique enableDcs a true, como no exemplo a seguir:

curl -X PATCH -n \
  https://<databricks-instance>/api/2.0/workspace-conf \
  -d '{
    "enableDcs": "true"
    }'