As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# 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](https://docs.aws.amazon.com/rekognition/latest/dg/limits.html) no Rekognition e na Referência da [API para obter informações sobre DetectLabels os limites de tamanho e tipo](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html) 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)**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Escolha a opção **Criar função**. Para obter mais informações, consulte [Criar uma função do Lambda com o console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html).
1. 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**.
1. Escolha **Criar função** para criar a função do AWS Lambda .
1. Na página da função, escolha a guia **Configuração**.
1. No painel **Permissões**, em **Função de execução**, escolha o nome do perfil para abrir o perfil no console do IAM.
1. Na guia **Permissões**, escolha **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Escolha a guia **JSON** e substitua a política pela seguinte política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "rekognition:DetectLabels",
"Resource": "*",
"Effect": "Allow",
"Sid": "DetectLabels"
}
]
}
```
------
1. Selecione **Revisar política**.
1. Insira um nome para a política, por exemplo *DetectLabels-access*.
1. Selecione **Criar política**.
1. 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 path}}Substitua pelo bucket e pelo caminho da pasta do Amazon S3 até os documentos que você deseja analisar.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3Access",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::{{bucket/folder path}}/*"
}
]
}
```
------
1. 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](https://docs.aws.amazon.com/lambda/latest/dg/invocation-layers.html#invocation-layers-using).
**Para criar e adicionar uma camada (console)**
1. 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/
```
1. Anote o nome do arquivo zip (boto3-layer.zip), que você usa na etapa 8 deste procedimento.
1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. No painel de navegação, escolha **Camadas**.
1. Escolha **Criar camada**.
1. Insira valores para **Nome** e **Descrição**.
1. Em **Tipo de entrada de código**, escolha **Carregar um arquivo.zip** e selecione **Upload**.
1. Na caixa de diálogo, escolha o arquivo zip (boto3-layer.zip) que você criou na etapa 1 deste procedimento.
1. Para **Tempos de execução compatíveis**, escolha a versão mais recente do Python.
1. Escolha **Criar** para criar a camada.
1. Escolha o ícone do menu do painel de navegação.
1. Selecione **Funções** no painel de navegação.
1. Na lista de recursos, escolha a função que você criou anteriormente em [](#lambda-s3-tutorial-python-create).
1. Escolha a guia **Código**.
1. Na seção **Camadas**, escolha **Adicionar uma camada**.
1. Escolha **camadas personalizadas**.
1. Em **Camadas personalizadas**, escolha o nome da camada que você inseriu na etapa 6.
1. Em **Versão**, escolha a versão da camada, que deve ser 1.
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)**
1. Navegue até a guia **Código** .
1. 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
```
1. 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)](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html#configuration-timeout-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](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html).
**Para testar sua função do Lambda**
1. 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:
Você pode obter o ARN da sua função do Lambda na visão geral da função no console do [Lambda](https://console.aws.amazon.com/lambda/).
Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:
+ Usuários e grupos em Centro de Identidade do AWS IAM:
Crie um conjunto de permissões. Siga as instruções em [Criação de um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
+ 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)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) 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](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) 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)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do IAM*.
1. Instale e configure o AWS SDK para Python. Para obter mais informações, consulte [Etapa 2: configurar o AWS CLI e AWS SDKs](setup-awscli-sdk.md).
1. 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)
```
1. 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 [](#lambda-s3-tutorial-python-create).
Se for bem-sucedido, seu código retornará uma resposta JSON parcial para cada tipo de bloco detectado no documento.