Crie uma função do Lambda (console) (Opcional) Crie uma camada (console) Adicionar código Python (console) Para adicionar código Python (console)

Detectando rótulos em uma imagem usando Lambda e Python

AWS Lambda é um serviço de computação que você pode usar para executar código sem provisionar ou gerenciar servidores. Você pode chamar operações da API Rekognition de dentro de uma função do Lambda. As instruções a seguir mostram como criar uma função do Lambda em Python que chame DetectLabels.

A função do Lambda chama DetectLabels e retorna uma matriz de rótulos detectados na imagem, bem como o nível de confiança pelo qual eles foram detectados.

As instruções incluem um exemplo de código Python que mostra como chamar a função do Lambda e fornecer a ela uma imagem proveniente de um bucket do Amazon S3 ou do seu computador local.

Certifique-se de que as imagens escolhidas atendam aos limites do Rekognition. Consulte Diretrizes e cotas no Rekognition e na Referência da API para obter informações sobre DetectLabels os limites de tamanho e tipo de arquivo de imagem.

Crie uma função do Lambda (console)

Nesta etapa, você cria uma função do Lambda vazia e uma função de execução do IAM que permite que sua função do Lambda chame a DetectLabels operação. Nas etapas posteriores, você adiciona o código-fonte e, opcionalmente, adiciona uma camada à função do Lambda.

Se você estiver usando documentos armazenados em um bucket do Amazon S3, esta etapa também demonstra como conceder acesso ao bucket que armazena seus documentos.

Para criar uma AWS Lambda função (console)

Faça login no AWS Management Console e abra o AWS Lambda console em https://console.aws.amazon.com/lambda/.
Escolha a opção Criar função. Para obter mais informações, consulte Criar uma função do Lambda com o console.
Escolha as seguintes opções:
- Escolha Criar do zero.
- Insira um valor para Nome da função.
- Para Runtime, escolha a versão mais recente do Python.
- Em Architecture (Arquitetura), escolha x86_64.
Escolha Criar função para criar a função do AWS Lambda .
Na página da função, escolha a guia Configuração.
No painel Permissões, em Função de execução, escolha o nome do perfil para abrir o perfil no console do IAM.
Na guia Permissões, escolha Adicionar permissões e, em seguida, Criar política em linha.

Escolha a guia JSON e substitua a política pela seguinte política:


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": "rekognition:DetectLabels",
            "Resource": "*",
            "Effect": "Allow",
            "Sid": "DetectLabels"
        }
    ]
}

Escolha Revisar política.
Insira um nome para a política, por exemplo DetectLabels-access.
Escolha Criar política.
Se você estiver armazenando documentos para análise em um bucket do Amazon S3, deverá adicionar uma política de acesso do Amazon S3. Para fazer isso, repita as etapas 7 a 11 no console da AWS Lambda e faça as seguintes alterações.
1. Para a etapa 8, use a política a seguir. bucket/folder pathSubstitua pelo bucket e pelo caminho da pasta do Amazon S3 até os documentos que você deseja analisar.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3Access",
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::bucket/folder path/*"
        }
    ]
}
```
2. Para a etapa 10, escolha um nome de política diferente, como S3Bucket-Access.

(Opcional) Crie uma camada (console)

Você não precisa executar essa etapa para usar uma função do Lambda e chamar DetectLabels.

A DetectLabels operação está incluída no ambiente padrão do Lambda Python como parte do AWS SDK for Python (Boto3).

Se outras partes da sua função do Lambda exigirem atualizações de AWS serviço recentes que não estejam no ambiente padrão do Lambda Python, você poderá realizar esta etapa para adicionar a versão mais recente do SDK do Boto3 como uma camada à sua função.

Para adicionar o SDK como uma camada, primeiro você cria um arquivo zip que contém o SDK do Boto3. Em seguida, você cria uma camada e adiciona o arquivo zip à camada. Para obter mais informações, consulte Usar camadas com sua função do Lambda.

Para criar e adicionar uma camada (console)

Abra um prompt de comando e insira os comandos a seguir para criar um pacote de implantação com a versão mais recente do AWS SDK.
```
pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                
```
Anote o nome do arquivo zip (boto3-layer.zip), que você usa na etapa 8 deste procedimento.
Abra o AWS Lambda console em https://console.aws.amazon.com/lambda/.
No painel de navegação, escolha Camadas.
Escolha Criar camada.
Insira valores para Nome e Descrição.
Em Tipo de entrada de código, escolha Carregar um arquivo.zip e selecione Upload.
Na caixa de diálogo, escolha o arquivo zip (boto3-layer.zip) que você criou na etapa 1 deste procedimento.
Para Tempos de execução compatíveis, escolha a versão mais recente do Python.
Escolha Criar para criar a camada.
Escolha o ícone do menu do painel de navegação.
Selecione Funções no painel de navegação.
Na lista de recursos, escolha a função que você criou anteriormente em .
Escolha a guia Código.
Na seção Camadas, escolha Adicionar uma camada.
Escolha camadas personalizadas.
Em Camadas personalizadas, escolha o nome da camada que você inseriu na etapa 6.
Em Versão, escolha a versão da camada, que deve ser 1.
Escolha Adicionar.

Adicionar código Python (console)

Nesta etapa, você adiciona seu código Python à sua função do Lambda por meio do editor de código do console Lambda. O código detecta rótulos em uma imagem usando a operação DetectLabels. Ele retorna uma matriz de rótulos detectados na imagem, bem como o nível de confiança nos rótulos detectados.

O documento que você fornece para a operação DetectLabels pode estar localizado em um bucket do Amazon S3 ou em um computador local.

Para adicionar código Python (console)

Navegue até a guia Código .

No editor de código, substitua o código em lambda_function.py pelo código a seguir:


import boto3
import logging
from botocore.exceptions import ClientError
import json
import base64

# Instantiate logger
logger = logging.getLogger(__name__)

# connect to the Rekognition client
rekognition = boto3.client('rekognition')

def lambda_handler(event, context):

    try:
        image = None
        if 'S3Bucket' in event and 'S3Object' in event:
            s3 = boto3.resource('s3')
            s3_object = s3.Object(event['S3Bucket'], event['S3Object'])
            image = s3_object.get()['Body'].read()

        elif 'image' in event:
            image_bytes = event['image'].encode('utf-8')
            img_b64decoded = base64.b64decode(image_bytes)
            image = img_b64decoded


        elif image is None:
            raise ValueError('Missing image, check image or bucket path.')

        else:
            raise ValueError("Only base 64 encoded image bytes or S3Object are supported.")

        response = rekognition.detect_labels(Image={'Bytes': image})
        lambda_response = {
            "statusCode": 200,
            "body": json.dumps(response)
        }
        labels = [label['Name'] for label in response['Labels']]
        print("Labels found:")
        print(labels)

    except ClientError as client_err:

       error_message = "Couldn't analyze image: " + client_err.response['Error']['Message']

       lambda_response = {
           'statusCode': 400,
           'body': {
               "Error": client_err.response['Error']['Code'],
               "ErrorMessage": error_message
           }
       }
       logger.error("Error function %s: %s",
                    context.invoked_function_arn, error_message)


    except ValueError as val_error:

        lambda_response = {
            'statusCode': 400,
            'body': {
                "Error": "ValueError",
                "ErrorMessage": format(val_error)
            }
        }
        logger.error("Error function %s: %s",
                     context.invoked_function_arn, format(val_error))

    return lambda_response

Escolha Implantar para implantar sua função do Lambda.

Para adicionar código Python (console)

Agora que você criou sua função do Lambda, você pode invocá-la para detectar rótulos em uma imagem.

Nesta etapa, você executa o código Python em seu computador, que passa uma imagem local ou uma imagem em um bucket do Amazon S3 para sua função do Lambda.

Certifique-se de executar o código na mesma AWS região em que você criou a função Lambda. Você pode visualizar a AWS região da sua função Lambda na barra de navegação da página de detalhes da função no console do Lambda.

Se a função do Lambda retornar um erro de tempo limite, estenda o período de tempo limite para a função do Lambda. Para obter mais informações, consulte Configurar o tempo limite da função (console).

Para obter mais informações sobre como invocar uma função do Lambda a partir do seu código, consulte Chamada de funções do AWS Lambda.

Para testar sua função do Lambda

Se você ainda não fez isso, faça o seguinte:
1. Certifique-se de que o usuário tenha permissão lambda:InvokeFunction. Você pode usar a seguinte política:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "InvokeLambda",
            "Effect": "Allow",
            "Action": "lambda:InvokeFunction",
            "Resource": "ARN for lambda function"
        }
    ]
}
```
  Você pode obter o ARN da sua função do Lambda na visão geral da função no console do Lambda.
  
  Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:
  - Usuários e grupos em AWS IAM Identity Center:
    
    Crie um conjunto de permissões. Siga as instruções em Criação de um conjunto de permissões no Guia do usuário do AWS IAM Identity Center .
  - Usuários gerenciados no IAM com provedor de identidades:
    
    Crie um perfil para a federação de identidades. Siga as instruções em Criando um perfil para um provedor de identidades de terceiros (federação) no Guia do Usuário do IAM.
  - Usuários do IAM:
    Crie um perfil que seu usuário possa assumir. Siga as instruções em Criação de um perfil para um usuário do IAM no Guia do usuário do IAM.
    
    (Não recomendado) Vincule uma política diretamente a um usuário ou adicione um usuário a um grupo de usuários. Siga as instruções em Adição de permissões a um usuário (console) no Guia do usuário do IAM.
2. Instale e configure o AWS SDK para Python. Para obter mais informações, consulte Etapa 2: configurar o AWS CLI e AWS SDKs.

Salve o código a seguir em um arquivo chamado client.py:


import boto3
import json
import base64
import pprint

# Replace with the name of your S3 bucket and image object key
bucket_name = "name of bucket"
object_key = "name of file in s3 bucket"
# If using a local file, supply the file name as the value of image_path below
image_path = ""

# Create session and establish connection to client['
session = boto3.Session(profile_name='developer-role')
s3 = session.client('s3', region_name="us-east-1")
lambda_client = session.client('lambda',  region_name="us-east-1")

# Replace with the name of your Lambda function
function_name = 'RekDetectLabels'

def analyze_image_local(img_path):

    print("Analyzing local image:")

    with open(img_path, 'rb') as image_file:
        image_bytes = image_file.read()
        data = base64.b64encode(image_bytes).decode("utf8")

        lambda_payload = {"image": data}

        # Invoke the Lambda function with the event payload
        response = lambda_client.invoke(
            FunctionName=function_name,
            Payload=(json.dumps(lambda_payload))
        )

        decoded = json.loads(response['Payload'].read().decode())
        pprint.pprint(decoded)

def analyze_image_s3(bucket_name, object_key):

    print("Analyzing image in S3 bucket:")

    # Load the image data from S3 into memory
    response = s3.get_object(Bucket=bucket_name, Key=object_key)
    image_data = response['Body'].read()
    image_data = base64.b64encode(image_data).decode("utf8")

     # Create the Lambda event payload
    event = {
        'S3Bucket': bucket_name,
        'S3Object': object_key,
        'ImageBytes': image_data
    }

    # Invoke the Lambda function with the event payload
    response = lambda_client.invoke(
            FunctionName=function_name,
            InvocationType='RequestResponse',
            Payload=json.dumps(event),
            )

    decoded = json.loads(response['Payload'].read().decode())
    pprint.pprint(decoded)

def main(path_to_image, name_s3_bucket, obj_key):

    if str(path_to_image) != "":
        analyze_image_local(path_to_image)
    else:
        analyze_image_s3(name_s3_bucket, obj_key)

if __name__ == "__main__":
    main(image_path, bucket_name, object_key)

Execute o código. Se o documento estiver em um bucket do Amazon S3, certifique-se de que seja o mesmo bucket que você especificou anteriormente na etapa 12 do .

Se for bem-sucedido, seu código retornará uma resposta JSON parcial para cada tipo de bloco detectado no documento.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usar o Amazon Rekognition (REK) para detectar rótulos para aplicativos de marketing

Exemplos de código