Criação de domínios e perfis de usuário do Amazon SageMaker Studio usando o AWS CloudFormation

Por Qingwei Li, David Ping e Joseph Jegan

O Amazon SageMaker Studio é o primeiro ambiente de desenvolvimento (IDE) totalmente integrado para machine learning (ML). Ele fornece uma única interface visual baseada na Web onde você pode executar todas as etapas de desenvolvimento de ML necessárias para criar, treinar, ajustar, depurar, implantar e monitorar modelos. Nesta publicação, demonstramos como você pode criar um domínio e um perfil de usuário do SageMaker Studio usando o AWS CloudFormation. O AWS CloudFormation oferece uma maneira fácil de modelar uma coleção de recursos relacionados da AWS e de terceiros, provisioná-los de forma rápida e consistente e gerenciá-los durante todo o ciclo de vida tratando a infraestrutura como código.

Como o AWS CloudFormation não está nativamente integrado ao SageMaker Studio no momento da redação, usamos o AWS CloudFormation para provisionar duas funções do AWS Lambda e, em seguida, invocar essas funções para criar, excluir e atualizar o domínio e o perfil de usuário do Studio. No resto desta postagem, percorremos a função do Lambda para criar o domínio Studio (o código para criar um perfil de usuário do Studio funciona de forma semelhante) e, em seguida, o modelo do CloudFormation. Todo o código está disponível no repositório do GitHub.

Função do Lambda para criar, excluir e atualizar um domínio do Studio

Na função do Lambda, o lambda_handler chama uma das três funções, handle_create, handle_update e handle_delete, para criar, atualizar e excluir o domínio do Studio, respectivamente. Como chamamos essa função usando um recurso personalizado do AWS CloudFormation, o tipo de solicitação de recurso personalizado é enviado no campo RequestType do AWS CloudFormation. RequestType determina qual função chamar dentro da função lambda_handler . Por exemplo, quando o AWS CloudFormation detecta quaisquer alterações na seção custom።StudioDomain do nosso modelo do CloudFormation, o requestType é definido como Update by AWS CloudFormation e a função handle_update é chamada. O seguinte é o código lambda_handler :

def handle_create(event, context):
    print("**Starting running the SageMaker workshop setup code")
    resource_config = event['ResourceProperties']
    print("**Creating studio domain")
    response_data = create_studio_domain(resource_config)
    cfnresponse.send(event, context, cfnresponse.SUCCESS,
                     {}, physicalResourceId=response_data['DomainArn'])

As três funções para criar, atualizar e excluir o domínio funcionam de forma semelhante. Para este post, percorremos o código responsável pela criação de um domínio. Ao invocar a função do Lambda por meio de um recurso personalizado do AWS CloudFormation, passamos os principais parâmetros que ajudam a definir nosso domínio Studio por meio das Propriedades do recurso personalizado. Extraímos esses parâmetros da fonte de eventos do AWS CloudFormation na função Lambda. Na função handle_create , os parâmetros são lidos do evento e passados para a função create_studio_domain . Consulte o seguinte código para handle_create:

def handle_create(event, context):
    print("**Starting running the SageMaker workshop setup code")
    resource_config = event['ResourceProperties']
    print("**Creating studio domain")
    response_data = create_studio_domain(resource_config)
    cfnresponse.send(event, context, cfnresponse.SUCCESS,
                     {}, physicalResourceId=response_data['DomainArn'])

Usamos um cliente Boto3 SageMaker para criar domínios do Studio. Para esta publicação, definimos o nome de domínio, a VPC e a sub-rede que o Studio usa e a função de execução do SageMaker para o domínio do Studio. Depois que a API create_domain é executada, verificamos o status de criação a cada 5 segundos. Quando a criação estiver concluída, retornamos o Amazon Resource Name (ARN) e o URL do domínio criado. A quantidade de tempo que o Lambda permite que uma função seja executada antes de pará-la é de 3 segundos por padrão. Portanto, certifique-se de que o limite de tempo limite da sua função do Lambda esteja definido adequadamente. Definimos o limite de tempo limite para 900 segundos. O seguinte é o código create_studio_domain (as funções para excluir e atualizar domínios também são implementadas usando boto3 e construídas de forma semelhante):

client = boto3.client('sagemaker')
def create_studio_domain(config):
    vpc_id = config['VPC']
    subnet_ids = config['SubnetIds']
    default_user_settings = config['DefaultUserSettings']
    domain_name = config['DomainName']

    response = client.create_domain(
        DomainName=domain_name,
        AuthMode='IAM',
        DefaultUserSettings=default_user_settings,
        SubnetIds=subnet_ids.split(','),
        VpcId=vpc_id
    )

    domain_id = response['DomainArn'].split('/')[-1]
    created = False
    while not created:
        response = client.describe_domain(DomainId=domain_id)
        time.sleep(5)
        if response['Status'] == 'InService':
            created = True

    logging.info("**SageMaker domain created successfully: %s", domain_id)
    return response

Finalmente, nós compactamos o script Python, salvá-lo como domain_function.zip e carregá-lo no Amazon Simple Storage Service (Amazon S3).

A função Lambda usada para criar um perfil de usuário é construída de forma semelhante. Para obter mais informações, consulte o script UserProfile_function.py no repositório do GitHub.

Modelo do CloudFormation

No modelo do CloudFormation, criamos uma função de execução para o Lambda, uma função de execução para o SageMaker Studio e a função Lambda usando o código explicado na seção anterior. Chamamos essa função especificando-a como o alvo de um recurso do cliente. Para obter mais informações sobre como invocar uma função do Lambda com o AWS CloudFormation, consulte Uso do AWS Lambda com o AWS CloudFormation.

Role de execução do Lambda

Essa role dá à nossa função Lambda a permissão para criar um fluxo de logs do Amazon CloudWatch e gravar logs no CloudWatch. Como criamos, excluímos e atualizamos domínios do Studio em nossa função, também concedemos a essa função a permissão para fazê-lo. Consulte o seguinte código:

LambdaExecutionRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - "sts:AssumeRole"
      Path: /

  LambdaExecutionPolicy:
    Type: AWS::IAM::ManagedPolicy
    Properties:
      Path: /
      PolicyDocument:
        Version: 2012-10-17
        Statement:
          - Sid: CloudWatchLogsPermissions
            Effect: Allow
            Action:
              - logs:CreateLogGroup
              - logs:CreateLogStream
              - logs:PutLogEvents
            Resource: !Sub "arn:${AWS::Partition}:logs:*:*:*"
          - Sid: SageMakerDomainPermission
            Effect: Allow
            Action:
              - sagemaker:CreateDomain
              - sagemaker:DescribeDomain
              - sagemaker:DeleteDomain
              - sagemaker:UpdateDomain
              - sagemaker:CreateUserProfile
              - sagemaker:UpdateUserProfile
              - sagemaker:DeleteUserProfile
              - sagemaker:DescribeUserProfile
            Resource:
              - !Sub "arn:${AWS::Partition}:sagemaker:*:*:domain/*"
              - !Sub "arn:${AWS::Partition}:sagemaker:*:*:user-profile/*"
          - Sid: SageMakerExecPassRole
            Effect: Allow
            Action:
              - iam:PassRole
            Resource: !GetAtt  SageMakerExecutionRole.Arn
      Roles:
        - !Ref LambdaExecutionRole

Role de execução do SageMaker

A seguinte role de execução do SageMaker é anexada ao Studio (para fins de demonstração, concedemos esta função SageMakerFullAccess):

SageMakerExecutionRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - sagemaker.amazonaws.com
            Action:
              - "sts:AssumeRole"
      Path: /
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/AmazonSageMakerFullAccess

Função Lambda

O recurso AWS።Lambda።Function cria uma função do Lambda. Para criar uma função, precisamos de um pacote de implantação e uma role de execução. O pacote de implantação contém nosso código de função (function.zip). A role de execução, que é o LambdaExecutionRole criado a partir da etapa anterior, concede à role permissão para criar uma função do Lambda. Também adicionamos o CFNResponseLayer ao ambiente de execução da nossa função. O CFNResponseLayer permite que a função interaja com um recurso personalizado do AWS CloudFormation. Ele contém um método de envio para enviar respostas do Lambda para o AWS CloudFormation. Consulte o seguinte código:

Resources:
...
 StudioDomainFunction:
    Type: AWS::Lambda::Function
    Properties:
      Handler: lambda_function.lambda_handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        S3Bucket: !Ref S3Bucket
        S3Key: function.zip
        S3ObjectVersion: !Ref S3ObjectVersion
      Runtime: python3.8
      Timeout: 900
      Layers:
        - !Ref CfnResponseLayer
       
  CfnResponseLayer:
    Type: AWS::Lambda::LayerVersion
    Properties:
      CompatibleRuntimes:
        - python3.8
      Content:
        S3Bucket: !Ref S3Bucket
        S3Key: cfnResponse-layer.zip
      Description: cfn-response layer
      LayerName: cfn-response

Invocar a função do Lambda usando um recurso personalizado do AWS CloudFormation

Os recursos personalizados fornecem uma maneira de escrever a lógica de provisionamento personalizada em um modelo do CloudFormation e fazer com que o AWS CloudFormation a execute durante uma operação da stack, como quando você cria, atualiza ou exclui uma stack. Para obter mais informações, consulte Recursos personalizados. Nós obtemos o ARN da função do Lambda criado a partir da etapa anterior e o passamos para o AWS CloudFormation como nosso token de serviço. Isso permite que o AWS CloudFormation execute a função do Lambda. Passamos os parâmetros necessários para criar, atualizar e excluir nosso domínio em Propriedades. Consulte o seguinte código:

StudioDomain:
    Type: Custom::StudioDomain
    Properties:
      ServiceToken: !GetAtt StudioDomainFunction.Arn
      VPC: !Ref VPCId
      SubnetIds: !Ref SubnetIds
      DomainName: "MyDomainName"
      DefaultUserSettings:
        ExecutionRole: !GetAtt SageMakerExecutionRole.Arn

Da mesma forma, invocamos a função Lambda para criar um perfil de usuário:

UserProfile:
    Type: Custom::UserProfile
    Properties:
      ServiceToken: !GetAtt UserProfileFunction.Arn
      DomainId: !GetAtt StudioDomain.DomainId
      UserProfileName: !Ref UserProfileName
      UserSettings:
        ExecutionRole: !GetAtt SageMakerExecutionRole.Arn

Conclusão

Nesta publicação, percorremos as etapas de criação, exclusão e atualização de domínios do SageMaker Studio usando o AWS CloudFormation e o Lambda. Os arquivos de exemplo estão disponíveis no repositório do GitHub. Para obter informações sobre a criação de domínio do Studio dentro de uma VPC, consulte Protegendo a conectividade do Amazon SageMaker Studio usando uma VPC privada. Para obter mais informações sobre o SageMaker Studio, consulte Introdução ao Amazon SageMaker Studio.

Este artigo foi traduzido do Blog da AWS em Inglês.

Sobre os autores

Qingwei Li é especialista em aprendizado de máquina na Amazon Web Services. Ele recebeu seu Ph.D. em Pesquisa de Operações depois que ele quebrou a conta de bolsa de pesquisa de seu conselheiro e não conseguiu entregar o Prêmio Nobel que ele prometeu. Atualmente, ele ajuda os clientes do setor de serviços financeiros e seguros a criar soluções de machine learning na AWS. Em seu tempo livre, ele gosta de ler e ensinar.

Joseph Jegan é arquiteto de aplicativos em nuvem da Amazon Web Services. Ele ajuda os clientes da AWS a usar os serviços da AWS para projetar aplicativos escaláveis e seguros. Ele tem mais de 20 anos de experiência em desenvolvimento de software antes da AWS, trabalhando no desenvolvimento de plataforma de comércio eletrônico para grandes clientes de varejo. Ele é baseado em Nova York e gosta de aprender tecnologias nativas emergentes em nuvem.

David Ping é um principal arquiteto de soluções de aprendizado de máquina e Gerente Sr. de Arquitetura de soluções de AI/ML na Amazon Web Services. Ele ajuda os clientes corporativos a criar e operar soluções de machine learning na AWS. Em seu tempo livre, David gosta de caminhar e ler os mais recentes artigos de aprendizado de máquina.

Revisor

Evandro Franco é um arquiteto de soluções do time de Startups na Amazon Web Services. Em sua função, ele ajuda as Startups a superar os desafios de negócio utilizando a plataforma da AWS. Ele tem mais de 15 anos de experiência na área de tecnologia. Em seu tempo livre, gosta de correr e passar tempo com sua família.

O blog da AWS