Pular para o conteúdo principal

Acesse os bucketsaccount S3 com uma política AssumeRole

Em AWS, o senhor pode configurar o acesso entreaccount, de modo que a computação em um account possa acessar um bucket em outro account. Uma maneira de conceder acesso, descrita no tutorial: Configurar o acesso S3 com um instance profile, é conceder a um account acesso direto a um bucket em outro account. Outra maneira de conceder acesso a um bucket é permitir que um account assuma uma função em outro account.

Considere a conta AWS A com account ID <deployment-acct-id> e a conta AWS B com account ID <bucket-owner-acct-id>. A conta A é usada ao se inscrever em Databricks: EC2 serviço e o bucket raiz Databricks Filesystem são gerenciados por este account. A conta B tem um balde <s3-bucket-name>.

Este artigo fornece as etapas para configurar a conta A para usar a ação AWS AssumeRole para acessar os arquivos S3 em <s3-bucket-name> como uma função na conta B. Para habilitar esse acesso, o senhor realiza a configuração na conta A e na conta B e nas configurações de administração Databricks. O senhor também deve configurar um clustering Databricks ou adicionar uma configuração a um Notebook que acesse o bucket.

Requisitos​

  • AWS acesso de administrador à função IAM e às políticas no AWS account da implantação Databricks e no AWS account do bucket S3.
  • Balde S3 de destino.
  • Se o senhor pretende ativar a criptografia para o bucket S3, deve adicionar o instance profile como um usuário de chave para o KMS key fornecido na configuração. Consulte Configurar criptografia para S3 com KMS.

Etapa 1: Na conta A, crie a função MyRoleA e anexe as políticas​

  1. Crie uma função chamada MyRoleA na conta A. O perfil da instância ARN é arn:aws:iam::<deployment-acct-id>:instance-profile/MyRoleA.

  2. Crie uma política que diga que uma função na conta A pode assumir MyRoleB na conta B. Anexe-a a MyRoleA. Clique Política em linha e cole na política:

    JSON
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "Stmt1487884001000",
          "Effect": "Allow",
          "Action": ["sts:AssumeRole"],
          "Resource": ["arn:aws:iam::<bucket-owner-acct-id>:role/MyRoleB"]
        }
      ]
    }

  3. Atualize a política da função da conta A usada para criar o clustering, adicionando a ação iam:PassRole a MyRoleA:

    JSON
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "Stmt1403287045000",
          "Effect": "Allow",
          "Action": [
            "ec2:AssociateDhcpOptions",
            "ec2:AssociateIamInstanceProfile",
            "ec2:AssociateRouteTable",
            "ec2:AttachInternetGateway",
            "ec2:AttachVolume",
            "ec2:AuthorizeSecurityGroupEgress",
            "ec2:AuthorizeSecurityGroupIngress",
            "ec2:CancelSpotInstanceRequests",
            "ec2:CreateDhcpOptions",
            "ec2:CreateInternetGateway",
            "ec2:CreateKeyPair",
            "ec2:CreateRoute",
            "ec2:CreateSecurityGroup",
            "ec2:CreateSubnet",
            "ec2:CreateTags",
            "ec2:CreateVolume",
            "ec2:CreateVpc",
            "ec2:CreateVpcPeeringConnection",
            "ec2:DeleteInternetGateway",
            "ec2:DeleteKeyPair",
            "ec2:DeleteRoute",
            "ec2:DeleteRouteTable",
            "ec2:DeleteSecurityGroup",
            "ec2:DeleteSubnet",
            "ec2:DeleteTags",
            "ec2:DeleteVolume",
            "ec2:DeleteVpc",
            "ec2:DescribeAvailabilityZones",
            "ec2:DescribeIamInstanceProfileAssociations",
            "ec2:DescribeInstanceStatus",
            "ec2:DescribeInstances",
            "ec2:DescribePrefixLists",
            "ec2:DescribeReservedInstancesOfferings",
            "ec2:DescribeRouteTables",
            "ec2:DescribeSecurityGroups",
            "ec2:DescribeSpotInstanceRequests",
            "ec2:DescribeSpotPriceHistory",
            "ec2:DescribeSubnets",
            "ec2:DescribeVolumes",
            "ec2:DescribeVpcs",
            "ec2:DetachInternetGateway",
            "ec2:DisassociateIamInstanceProfile",
            "ec2:ModifyVpcAttribute",
            "ec2:ReplaceIamInstanceProfileAssociation",
            "ec2:RequestSpotInstances",
            "ec2:RevokeSecurityGroupEgress",
            "ec2:RevokeSecurityGroupIngress",
            "ec2:RunInstances",
            "ec2:TerminateInstances"
          ],
          "Resource": ["*"]
        },
        {
          "Effect": "Allow",
          "Action": "iam:PassRole",
          "Resource": ["arn:aws:iam::<deployment-acct-id>:role/MyRoleA"]
        }
      ]
    }
nota

Se o seu account estiver na versão E2 da plataforma Databricks, o senhor poderá omitir ec2:CreateKeyPair e ec2:DeleteKeyPair.

Etapa 2: Na conta B, crie a função MyRoleB e anexe as políticas​

  1. Crie uma função chamada MyRoleB. O ARN da função é arn:aws:iam::<bucket-owner-acct-id>:role/MyRoleB.

  2. Edite a relação de confiança da função MyRoleB para permitir que uma função MyRoleA na conta A assuma uma função na conta B. Selecione IAM role > MyRoleB > Trust relationships > Edit trust relationship e digite:

    JSON
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": {
            "AWS": ["arn:aws:iam::<deployment-acct-id>:role/MyRoleA"]
          },
          "Action": "sts:AssumeRole"
        }
      ]
    }

  3. Crie uma política de bucket para o bucket <s3-bucket-name>. Selecione S3 > <s3-bucket-name> > Permissions > Bucket Policy . Inclua a função (Principal) MyRoleB na política do bucket:

    JSON
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": {
            "AWS": ["arn:aws:iam::<bucket-owner-acct-id>:role/MyRoleB"]
          },
          "Action": ["s3:GetBucketLocation", "s3:ListBucket"],
          "Resource": "arn:aws:s3:::<s3-bucket-name>"
        },
        {
          "Effect": "Allow",
          "Principal": {
            "AWS": ["arn:aws:iam::<bucket-owner-acct-id>:role/MyRoleB"]
          },
          "Action": ["s3:PutObject", "s3:PutObjectAcl", "s3:GetObject", "s3:DeleteObject"],
          "Resource": "arn:aws:s3:::<s3-bucket-name>/*"
        }
      ]
    }
dica

Se você receber um Principal error, certifique-se de ter modificado somente a política de relacionamento de confiança .

Etapa 3: Adicionar MyRoleA ao site Databricks workspace​

Nas configurações administrativas do Databricks, adicione o instance profile MyRoleA ao Databricks usando o MyRoleA instance profile ARN arn:aws:iam::<deployment-acct-id>:instance-profile/MyRoleA da etapa 1.

Etapa 4: Configure o clustering com MyRoleA​

  1. Selecione ou crie um clustering.

  2. Abra a seção Avançado .

  3. Em Instances (Instâncias ) tab, selecione instance profileMyRoleA.

  4. Na seção Spark tab defina o provedor de credenciais de função assumida e a função ARN MyRoleB:

nota

Databricks Runtime 7.3 LTS e acima suportam a configuração do sistema de arquivos S3A usando as opções do código aberto Hadoop. Você pode configurar propriedades globais e propriedades por bucket.

Para configurá-lo globalmente para todos os buckets:

Bash
fs.s3a.aws.credentials.provider org.apache.hadoop.fs.s3a.auth.AssumedRoleCredentialProvider
fs.s3a.assumed.role.arn arn:aws:iam::<bucket-owner-account-id>:role/MyRoleB

Para configurá-lo para um bucket específico:

Bash
fs.s3a.bucket.<s3-bucket-name>.aws.credentials.provider org.apache.hadoop.fs.s3a.auth.AssumedRoleCredentialProvider
fs.s3a.bucket.<s3-bucket-name>.assumed.role.arn arn:aws:iam::<bucket-owner-account-id>:role/MyRoleB

  1. começar o agrupamento.

  2. Anexar um Notebook ao clustering.

  3. Verifique se o senhor pode acessar <s3-bucket-name> executando o seguinte comando:

    Python
    dbutils.fs.ls("s3a://<s3-bucket-name>/")

Etapa 5: Montar o bucketaccount com AssumeRole​

O senhor pode montar seu bucket entreaccount para usar caminhos de arquivos relativos para acessar dados remotos. Consulte Montar um bucket usando o perfil de instância com a política AssumeRole.

Configuração automatizada usando o Terraform​

O senhor pode usar o provedorDatabricks Terraform para configurar automaticamente a função AWS IAM e seu anexo de clustering.

Conforme mostrado neste exemplo de configuração, primeiro defina duas variáveis:

variable "prefix" {
  default = "changeme"
}

variable "databricks_account_id" {
  description = "Account ID. You can get your account ID in the bottom left corner of the account console. See https://accounts.cloud.databricks.com"
}

Crie um bucket usando aws_s3_bucket:

resource "aws_s3_bucket" "ds" {
  bucket = "${var.prefix}-ds"
  acl    = "private"
  versioning {
    enabled = false
  }
  force_destroy = true
  tags = merge(var.tags, {
    Name = "${var.prefix}-ds"
  })
}

Crie um IAM role para acesso a dados usando aws_iam_role:

data "aws_iam_policy_document" "assume_role_for_ec2" {
  statement {
    effect  = "Allow"
    actions = ["sts:AssumeRole"]
    principals {
      identifiers = ["ec2.amazonaws.com"]
      type        = "Service"
    }
  }
}

resource "aws_iam_role" "data_role" {
  name               = "${var.prefix}-first-ec2s3"
  description        = "(${var.prefix}) EC2 Assume Role role for S3 access"
  assume_role_policy = data.aws_iam_policy_document.assume_role_for_ec2.json
  tags               = var.tags
}

Crie uma política de bucket com uma definição de databricks_aws_bucket_policy que dê acesso total a esse bucket. Aplique uma política de bucket S3 em linha ao bucket recém-criado com aws_s3_bucket_policy:

data "databricks_aws_bucket_policy" "ds" {
  provider         = databricks.mws
  full_access_role = aws_iam_role.data_role.arn
  bucket           = aws_s3_bucket.ds.bucket
}

resource "aws_s3_bucket_policy" "ds" {
  bucket = aws_s3_bucket.ds.id
  policy = data.databricks_aws_bucket_policy.ds.json
}

Crie uma política entreaccount, que permita que Databricks passe uma lista de funções de dados usando uma aws_iam_policy:

data "databricks_aws_crossaccount_policy" "this" {
  pass_roles = [aws_iam_role.data_role.arn]
}

resource "aws_iam_policy" "cross_account_policy" {
  name   = "${var.prefix}-crossaccount-iam-policy"
  policy = data.databricks_aws_crossaccount_policy.this.json
}

Permita que o Databricks execute ações no seu account configurando uma relação de confiança usando um aws_iam_role_policy_attachment. Conceda a Databricks acesso total ao recurso VPC e anexe a políticaaccount à funçãoaccount:

data "databricks_aws_assume_role_policy" "this" {
    external_id = var.databricks_account_id
}

resource "aws_iam_role" "cross_account" {
  name               = "${var.prefix}-crossaccount-iam-role"
  assume_role_policy = data.databricks_aws_assume_role_policy.this.json
  description        = "Grants Databricks full access to VPC resources"
}

resource "aws_iam_role_policy_attachment" "cross_account" {
  policy_arn = aws_iam_policy.cross_account_policy.arn
  role       = aws_iam_role.cross_account.name
}

registro cruzado -account função na configuração do E2 workspace:

resource "databricks_mws_credentials" "this" {
  provider         = databricks.mws
  account_id       = var.databricks_account_id
  credentials_name = "${var.prefix}-creds"
  role_arn         = aws_iam_role.cross_account.arn
}

Depois que o workspace for criado, registre sua função de dados com aws_iam_instance_profile como databricks_instance_profile:

resource "aws_iam_instance_profile" "this" {
  name = "${var.prefix}-first-profile"
  role = aws_iam_role.data_role.name
}

resource "databricks_instance_profile" "ds" {
  instance_profile_arn = aws_iam_instance_profile.this.arn
}

Na última etapa, crie um ponto de montagem /mnt/experiments e um clustering com um instance profile especificado:

resource "databricks_aws_s3_mount" "this" {
    instance_profile = databricks_instance_profile.ds.id
    s3_bucket_name = aws_s3_bucket.this.bucket
    mount_name = "experiments"
}

data "databricks_node_type" "smallest" {
  local_disk = true
}

data "databricks_spark_version" "latest_lts" {
  long_term_support = true
}

resource "databricks_cluster" "shared_autoscaling" {
  cluster_name            = "Shared Autoscaling"
  spark_version           = data.databricks_spark_version.latest_lts.id
  node_type_id            = data.databricks_node_type.smallest.id
  autotermination_minutes = 20

  autoscale {
    min_workers = 1
    max_workers = 50
  }

  aws_attributes {
    instance_profile_arn = databricks_instance_profile.ds.id
  }
}
Última atualização em