Pular para o conteúdo principal
Última atualização em

Databricks Container Services para computepadrão

info

Beta

Databricks Container Services para compute padrão está em versão Beta. O administrador workspace deve habilitar esse recurso na página de pré-visualizações workspace . Este é um serviço separado do Databricks Container Services para computededicada, que está disponível ao público em geral.

Databricks Container Services para compute padrão permite que você especifique uma imagem Docker ao criar computepadrão, dando acesso a contêineres personalizados em ambientes compute compartilhados. Sua imagem Docker é a única definição do ambiente de carga de trabalho, portanto, você pode reproduzir o ambiente remoto localmente para obter resultados consistentes em ambientes de desenvolvimento e produção.

Além disso, para ajudar na criação de sua imagem personalizada, Databricks fornece uma imagem base alinhada com as versões de ambienteserverless , que você pode estender para atender às suas necessidades.

Requisitos​

Para usar Databricks Container Services para compute padrão:

  • O recurso de compute deve estar executando o Databricks Runtime 18 Beta ou superior e usar o modo de acesso **Standard**.
  • Você deve ter um daemon Docker recente com o comando docker disponível em seu PATH.

Passo 1: Habilitar Databricks Container Services para computepadrão​

Para usar Databricks Container Services para compute padrão, um administrador workspace deve habilitar o recurso na página de Pré-visualizações :

  1. Faça login no seu workspace Databricks como administrador.
  2. No menu do usuário, localizado no canto superior direito, clique em Visualizações .
  3. Localize o DCS para computepadrão e ative-o.

a etapa 2: Crie sua imagem personalizada​

Estas instruções mostram como criar uma imagem personalizada estendendo uma imagem base fornecida pelo Databricks (recomendado). A imagem base contém as dependências necessárias para executar suas cargas de trabalho, como Ubuntu, Python e JDK. Você pode extrair databricksruntime/environment:v5-standard, adicionar seu pacote por cima e herdar atualizações contínuas Databricks-gerenciar e patches de segurança.

Se você deseja criar uma imagem base mínima do zero, consulte a Referência: criar uma imagem base mínima do zero.

o passo 2a: Puxe a imagem base​

Para extrair a imagem base, execute:

Bash
docker pull databricksruntime/environment:v5-standard

Para instâncias do AWS Graviton (ARM), utilize a variante ARM:

  • databricksruntime/environment:v5-standard-arm

o passo 2b: Escreva um Dockerfile que estenda a imagem base​

Instale o pacote Python personalizado no ambiente virtual /databricks/python3 da imagem base. Este é o ambiente virtual do sistema que executa suas cargas de trabalho.

Se você estiver segmentando tipos de instância do AWS Graviton, substitua :v5-standard por :v5-standard-arm na linha FROM .

Dockerfile
FROM databricksruntime/environment:v5-standard

RUN /databricks/python3/bin/python -m pip install <your python package>

O exemplo a seguir mostra como instalar um pacote de um repositório privado.

Dockerfile
FROM databricksruntime/environment:v5-standard

ENV PIP_INDEX_URL=https://pypi.org/simple

RUN /databricks/python3/bin/python -m pip install --no-cache-dir simplejson

Você pode usar qualquer instrução padrão do Dockerfile (por exemplo, RUN, ENV, WORKDIR, COPY). As instruções a seguir são ignoradas devido à forma como o Databricks inicia sua carga de trabalho:

  • USER
  • CMD
  • ENTRYPOINT
  • EXPOSE
  • HEALTHCHECK
  • SHELL
  • STOPSIGNAL
nota

Para cargas de trabalho Scala, copie seus arquivos JAR para o diretório /scala-jars/user na imagem e marque-os com chmod 0644 para que o usuário do sandbox possa lê-los. O Databricks carrega os arquivos JAR deste caminho para o classpath do Spark.

o passo 2c: Construir a imagem​

Para construir a imagem, execute:

Bash
docker build -f <your-dockerfile> -t <registry-url>/<project>[/<repo>]:<tag> .
atenção

Teste minuciosamente sua imagem personalizada em um compute Databricks . Uma imagem que funciona em uma máquina local ou de compilação pode não iniciar, desativar silenciosamente o recurso ou parar de funcionar quando executada no Databricks.

Referência: construir uma imagem base mínima do zero​

Se você precisar de controle total sobre o conteúdo da sua imagem base (por exemplo, para atender a requisitos rigorosos de tamanho de imagem, cadeia de suprimentos ou compliance ), você pode construir um equivalente mínimo de databricksruntime/environment:v5-standard do zero em vez de estendê-lo.

atenção

Construir do zero é uma opção avançada. Você assume a responsabilidade pelo acompanhamento das alterações upstream na imagem v5-standard , incluindo Python pin, patches de segurança, ferramentas de plataforma e os arquivos necessários da plataforma em /databricks/ e /etc/environment. Em vez disso, Databricks recomenda estender databricksruntime/environment:v5-standard conforme mostrado anteriormente no passo 2.

O Databricks fornece um Dockerfile de referência e requirements.txt que recriam o ambiente Python essencial de v5-standard. Faça o download de ambos os arquivos para o mesmo diretório antes de compilar:

Para construir a imagem, execute:

Bash
docker build -t <your-registry>/<repo>:<tag> .

Se o seu host de compilação não conseguir acessar https://pypi.org, sobrescreva o índice do pip durante a compilação executando o seguinte comando:

Bash
docker build --build-arg PIP_INDEX_URL=https://your-mirror/simple -t <your-registry>/<repo>:<tag> .

Antes de continuar para o próximo passo, verifique se os pacotes Python organizados importam corretamente executando:

Bash
docker run --rm --cpus 2 <your-registry>/<repo>:<tag> \
  /databricks/python3/bin/python -c \
  "import pandas, numpy, pyarrow, mlflow, databricks.connect; print('OK')"

o passo 3: Envie sua imagem para um registro​

Em seguida, envie sua imagem para um registro Docker. Databricks Container Services suporta os mesmos registros tanto em computação padrão quanto compute dedicada:

Outros registros que não suportam autenticação ou que suportam autenticação básica também devem funcionar. A autenticação básica utiliza seu nome de usuário e senha de registro.

Para obter o melhor desempenho na extração de imagens, use um registro na mesma cloud e região que seu workspace Databricks .

Bash
echo "$REGISTRY_PASSWORD" | docker login -u <registry-username> --password-stdin <registry-url>
docker push <registry-url>/<project>[/<repo>]:<tag>
nota

Se você usa Docker Hub, verifique se seus limites de taxa são compatíveis com a compute que você espera executar em um período de seis horas. Consulte a documentação do Docker para obter mais detalhes. Se este limite for excedido, as solicitações retornarão 429 Too Many Requests.

o passo 4: Inicie seu compute​

Você pode iniciar compute que utilizam sua imagem personalizada por meio da interface do usuário ou API. Os seguintes requisitos devem ser atendidos:

  • O modo de acesso compute deve ser Padrão (na API, defina data_security_mode para DATA_SECURITY_MODE_STANDARD). Se o modo de compute estiver definido como Acesso Dedicado , será utilizada uma versão diferente do Databricks Container Services , que espera uma imagem base diferente e não será iniciada com a imagem base que você criou.
  • A versão do Databricks Runtime precisa ser **18 Beta** ou acima.
nota

Para executar contra um pool de instâncias, o pool deve ser criado com preloaded_docker_images definido e o docker_image do cluster deve corresponder. Consulte a seção "Usar Databricks Container Services com um poolde instâncias" antes de iniciar.

Inicie seu compute usando a interface do usuário.​

  1. Na página Criar compute, certifique-se de que o **Modo de acesso** esteja definido como **Standard** e o **Databricks Runtime** esteja definido como **18 Beta** ou acima.

  2. Em Avançado , selecione a tab Docker .

  3. Selecione Usar seu próprio contêiner do Docker .

  4. No campo URLDocker Image , insira sua imagem personalizada.

    Registro

    Formato da etiqueta

    Docker Hub

    <organization>/<repository>:<tag> (por exemplo: databricksruntime/environment:v5-standard)

    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>

  5. Selecione o tipo de autenticação. Consulte Autenticação de imagemDocker.

nota

Se você não visualizar as configurações Docker ao criar compute, Databricks Container Services podem não estar habilitados em seu workspace. Um administrador workspace deve habilitá-lo antes que qualquer usuário possa especificar uma imagem Docker . Veja o passo 1: Habilitar Databricks Container Services para computepadrão.

Inicie seu compute usando a API​

A seguir, um exemplo de chamada API que cria um compute padrão com sua imagem personalizada. Certifique-se de que data_security_mode esteja definido como DATA_SECURITY_MODE_STANDARD e spark_version esteja definido como 18.x-scala2.13 ou acima.

Com imagem pública (sem autenticação):

Bash
databricks clusters create \
--cluster-name <cluster-name> \
--node-type-id <node-type> \
--json '{
  "num_workers": 1,
  "docker_image": {
    "url": "<docker-registry-image-url>"
  },
  "spark_version": "18.x-scala2.13",
  "aws_attributes": {
    "availability": "ON_DEMAND"
  },
  "data_security_mode": "DATA_SECURITY_MODE_STANDARD"
}'

Com autenticação básica:

Bash
databricks clusters create \
--cluster-name <cluster-name> \
--node-type-id <node-type> \
--json '{
  "num_workers": 1,
  "docker_image": {
    "url": "<docker-registry-image-url>",
    "basic_auth": {
      "username": "<docker-registry-username>",
      "password": "<docker-registry-password>"
    }
  },
  "spark_version": "18.x-scala2.13",
  "aws_attributes": {
    "availability": "ON_DEMAND"
  },
  "data_security_mode": "DATA_SECURITY_MODE_STANDARD"
}'

Com um instance profile (para ECR):

Bash
databricks clusters create \
--cluster-name <cluster-name> \
--node-type-id <node-type> \
--json '{
  "num_workers": 1,
  "docker_image": {
    "url": "<image-url>"
  },
  "spark_version": "18.x-scala2.13",
  "aws_attributes": {
    "availability": "ON_DEMAND",
    "instance_profile_arn": "arn:aws:iam::<aws-account-number>:instance-profile/<iam-role-name>"
  },
  "data_security_mode": "DATA_SECURITY_MODE_STANDARD"
}'

Autenticação de imagemDocker​

Os requisitos de autenticação dependem do tipo de imagem Docker que você possui. Você também pode usar segredos para armazenar nomes de usuário e senhas de autenticação. Consulte Usar segredos para autenticação.

  • Para imagens Docker públicas, não é necessário incluir informações de autenticação. Na interface do usuário, defina a autenticação como padrão . Para a chamada da API, não inclua os campos basic_auth .

  • Para imagens Docker privadas, autentique-se usando um ID e senha da entidade de serviço (ou segredos aplicáveis) como nome de usuário e senha.

  • Para o Registro de Contêineres do Azure, autentique-se usando um ID de entidade de serviço e senha (ou segredos aplicáveis) como nome de usuário e senha. Consulte a documentação de autenticação da entidade de serviçoAzure Container Registry para obter informações sobre a criação da entidade de serviço.

  • Para imagens ECR , não incluir informações de autenticação. Em vez disso, inicie seu compute com um instance profile que inclua permissões para extrair a imagem Docker do repositório Docker onde a imagem reside. Para isso, siga os passos 3 e 4 do processo de configuração de acesso seguro a buckets S3 usando o perfil de instância.

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

    JSON
    {
      "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 ECR residir em uma account AWS diferente da compute do Databricks , use uma política de repositório do ECR além do instance profile compute para conceder o acesso compute . Segue um exemplo de uma política de repositório ECR. A IAM role assumida pelo instance profile do compute é especificada por <arn-of-IAM-role>.

    JSON
    {
      "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 segredos para autenticação​

O serviço Databricks Container suporta o uso de segredos para autenticação. Ao criar seu recurso compute na interface do usuário, use o campo Autenticação para selecionar Nome de usuário e senha e, em vez de inserir seu nome de usuário ou senha em texto simples, insira seus segredos usando o formato {{secrets/<scope-name>/<dcs-secret>}} . Se você usar a API, insira os segredos nos campos basic_auth .

Para obter informações sobre a criação de segredos, consulte Gerenciamento de segredos.

Utilize Databricks Container Services com um poolde instâncias.​

Para usar Databricks Container Services com um pool de instâncias, você deve criar o pool usando a APIde pool de instâncias, e não a interface do usuário.

O pool deve ser criado com a imagem Docker pré-carregada. Isso aquece as instâncias do Parado com sua imagem personalizada para que as cargas de trabalho comecem mais rapidamente. Defina o campo preloaded_docker_images na solicitação com as mesmas referências de imagem e autenticação que você usa ao iniciar o compute diretamente. O campo é uma lista, portanto, um único pool pode pré-carregar várias imagens.

O pool e o recurso compute associado a ele devem concordar sobre se Docker está em uso. Se um pool não tiver preloaded_docker_images definido, você não poderá iniciar compute Databricks Container Services nele. Crie um novo pool com preloaded_docker_images definido.

Para pool criado com preloaded_docker_images, qualquer recurso compute lançado contra o pool deve fornecer um docker_image correspondente em sua solicitação de criação. Caso contrário, a criação compute falha com 'docker_image' must be provided for cluster created with instance pool: <pool-id>.

Migre dos Databricks Container Servicesoriginais.​

Databricks Container Services para compute padrão é um serviço diferente do Databricks Container Services original para computededicada. Este recurso apresenta as seguintes diferenças:

  • As cargas de trabalho são executadas através do protocolo Spark Connect .

  • O script de inicialização não modifica o ambiente Python da sua carga de trabalho. Você deve instalar todas as dependências Python na imagem Docker . Você pode continuar usando o script de inicialização para aplicativos que consomem dados do Spark, como agentes Datadog ou Kafka .

  • Suporte para tipos de instância do AWS Graviton.

Para migrar do Databricks Container Services original para compute dedicada, reconstrua sua imagem personalizada no Databricks Container Services para compute padrão e atualize sua configuração compute :

  1. Substitua a linha FROM no seu Dockerfile por FROM databricksruntime/environment:v5-standard (ou v5-standard-arm para AWS Graviton).
  2. Adapte as instruções do seu Dockerfile para a nova imagem base. As instruções padrão do Dockerfile são suportadas, com as exceções listadas na etapa 2: Crie sua imagem personalizada.
  3. Instale o pacote Python em /databricks/python3 em vez de qualquer outro ambiente virtual. As cargas de trabalho (Notebook, tarefa Python wheel , tarefa de script Python ) são lidas deste caminho.
  4. Atualize a configuração de compute para usar o modo de acesso **Standard** e o Databricks Runtime 18 Beta ou acima.
  5. Mova para o Dockerfile qualquer configuração de ambiente Python que um init script tenha executado anteriormente.

Limitações​

Além das limitações compute padrão, Databricks Container Services para compute padrão apresenta as seguintes limitações:

  • Bibliotecas com escopo computacional não são suportadas.
  • Repositórios de pacotes privados não são suportados.
  • O Databricks Runtime para Machine Learning não é compatível.
  • Para executar compute padrão com Databricks Container Services em um poolde instâncias, o pool deve ser criado com preloaded_docker_images definido. Consulte Usar Databricks Container Services com um poolde instâncias.

Solução de problemas​

Se a tab Docker não aparecer em Avançado ao criar compute, Databricks Container Services não está habilitado para seu workspace. Um administrador workspace deve habilitá-lo no workspace antes que qualquer usuário possa especificar uma imagem Docker . Veja o passo 1: Habilitar Databricks Container Services para computepadrão.

Nesta página