Analisando imagens com uma AWS Lambda função

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

Escolha as seguintes opções:

Escolha Criar função para criar a função do AWS Lambda .

Em sua página da função, escolha a guia Configuração.

No painel Variáveis de ambiente, escolha Editar.

Adicione as seguintes variáveis de ambiente: Para cada variável, escolha Adicionar variável de ambiente, e insira a chave e o valor da variável.

Escolha Salvar para salvar as variáveis de ambiente.

No painel Permissões, em Nome da função, escolha a função de execução para abrir a função no IAM console.

Na guia Permissões, escolha Adicionar permissões e Criar política em linha.

Escolha JSONe substitua a política existente pela política a seguir.

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

Escolha Próximo.

Em Detalhes da política, insira um nome para a política, como DetectCustomLabels-access.

Escolha Criar política.

Se estiver armazenando imagens para análise em um bucket do Amazon S3, repita as etapas 10 a 14.

1. Para a etapa 11, use a política a seguir. Substituir bucket/folder path com o bucket do Amazon S3 e o caminho da pasta para as imagens 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 13, escolha um nome de política diferente, como S3Bucket-access.

Abra um prompt de comando e execute os comandos a seguir.

pip install boto3 --target python/.
zip boto3-layer.zip -r python/
                

Observe o nome do arquivo zip (boto3-layer.zip). Ele será necessário na etapa 6 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.

Escolha Fazer upload de um arquivo .zip e escolha Fazer upload.

Na caixa de diálogo, escolha o arquivo de arquivos.zip (boto3-layer.zip) criada na etapa 1 desse procedimento.

Para runtimes compatíveis, escolha Python 3.9.

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 em Etapa 1: criar uma AWS Lambda função (console).

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.

Se não estiver no console do Lambda, faça o seguinte:

1. Abra o AWS Lambda console em https://console.aws.amazon.com/lambda/.

2. Abra a função do Lambda que você criou em Etapa 1: criar uma AWS Lambda função (console).

Escolha a guia Código.

Em Código-fonte, substitua o código em lambda_function.py pelo seguinte:

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
An AWS lambda function that analyzes images with an the Amazon Rekognition
Custom Labels model.
"""
import json
import base64
from os import environ
import logging
import boto3

from botocore.exceptions import ClientError

# Set up logging.
logger = logging.getLogger(__name__)

# Get the model ARN and confidence.
model_arn = environ['MODEL_ARN']
min_confidence = int(environ.get('CONFIDENCE', 50))

# Get the boto3 client.
rek_client = boto3.client('rekognition')


def lambda_handler(event, context):
    """
    Lambda handler function
    param: event: The event object for the Lambda function.
    param: context: The context object for the lambda function.
    return: The labels found in the image passed in the event
    object.
    """

    try:

        # Determine image source.
        if 'image' in event:
            # Decode the image
            image_bytes = event['image'].encode('utf-8')
            img_b64decoded = base64.b64decode(image_bytes)
            image = {'Bytes': img_b64decoded}


        elif 'S3Object' in event:
            image = {'S3Object':
                     {'Bucket':  event['S3Object']['Bucket'],
                      'Name': event['S3Object']['Name']}
                     }

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


        # Analyze the image.
        response = rek_client.detect_custom_labels(Image=image,
            MinConfidence=min_confidence,
            ProjectVersionArn=model_arn)

        # Get the custom labels
        labels = response['CustomLabels']

        lambda_response = {
            "statusCode": 200,
            "body": json.dumps(labels)
        }

    except ClientError as err:
        error_message = f"Couldn't analyze image. " + \
            err.response['Error']['Message']

        lambda_response = {
            'statusCode': 400,
            'body': {
                "Error": 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.

Certifique-se de que você tem a permissão lambda:InvokeFunction. É possível usar a política a seguir.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "InvokeLambda",
            "Effect": "Allow",
            "Action": "lambda:InvokeFunction",
            "Resource": "ARN for lambda function"
        }
    ]
}

Você pode obter a função ARN para sua função Lambda na visão geral da função no console Lambda.

Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:

Instale e configure AWS SDK para Python. Para obter mais informações, consulte Etapa 4: configurar os AWS SDKs AWS CLI e.

Inicie o modelo que você especificou na etapa 7 de Etapa 1: criar uma AWS Lambda função (console).

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

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
Test code for running the Amazon Rekognition Custom Labels Lambda
function example code.
"""

import argparse
import logging
import base64
import json
import boto3

from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)


def analyze_image(function_name, image):
    """Analyzes an image with an AWS Lambda function.
    :param image: The image that you want to analyze.
    :return The status and classification result for
    the image analysis.
    """

    lambda_client = boto3.client('lambda')

    lambda_payload = {}

    if image.startswith('s3://'):
        logger.info("Analyzing image from S3 bucket: %s", image)
        bucket, key = image.replace("s3://", "").split("/", 1)
        s3_object = {
            'Bucket': bucket,
            'Name': key
        }
        lambda_payload = {"S3Object": s3_object}

    # Call the lambda function with the image.
    else:
        with open(image, 'rb') as image_file:
            logger.info("Analyzing local image image: %s ", image)
            image_bytes = image_file.read()
            data = base64.b64encode(image_bytes).decode("utf8")

            lambda_payload = {"image": data}

    response = lambda_client.invoke(FunctionName=function_name,
                                    Payload=json.dumps(lambda_payload))

    return json.loads(response['Payload'].read().decode())


def add_arguments(parser):
    """
    Adds command line arguments to the parser.
    :param parser: The command line parser.
    """

    parser.add_argument(
        "function", help="The name of the AWS Lambda function that you want " \
        "to use to analyze the image.")
    parser.add_argument(
        "image", help="The local image that you want to analyze.")


def main():
    """
    Entrypoint for script.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        # Get command line arguments.
        parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
        add_arguments(parser)
        args = parser.parse_args()

        # Get analysis results.
        result = analyze_image(args.function, args.image)
        status = result['statusCode']

        if status == 200:
            labels = result['body']
            labels = json.loads(labels)
            print(f"There are {len(labels)} labels in the image.")
            for custom_label in labels:
                confidence = int(round(custom_label['Confidence'], 0))
                print(
                    f"Label: {custom_label['Name']}: Confidence: {confidence}%")
        else:
            print(f"Error: {result['statusCode']}")
            print(f"Message: {result['body']}")

    except ClientError as error:
        logging.error(error)
        print(error)


if __name__ == "__main__":
    main()

Execute o código. Para o argumento da linha de comando, forneça o nome da função do Lambda e a imagem que você deseja analisar. É possível fornecer um caminho para uma imagem local ou o caminho do S3 para uma imagem armazenada em um bucket do Amazon S3. Por exemplo:

python client.py function_name s3://bucket/path/image.jpg

Se a imagem estiver em um bucket do Amazon S3, certifique-se de que seja o mesmo bucket que você especificou na etapa 15 de Etapa 1: criar uma AWS Lambda função (console).

Se for bem-sucedida, a saída será uma lista de rótulos encontrados na imagem. Se nenhum rótulo for retornado, considere reduzir o valor de confiança que você definiu na etapa 7 do Etapa 1: criar uma AWS Lambda função (console).

Se você tiver concluído a função do Lambda e o modelo não for usado por outras aplicações, interrompa o modelo. Inicie o modelo na próxima vez que quiser usar a função do Lambda.