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á.

# Tutorial: Creating an Amazon Rekognition Lambda Application
<a name="lambda-rekognition-example"></a>

Este tutorial mostra como criar uma aplicação do Lambda que usa o Amazon Rekognition para marcar objetos do Amazon S3 com rótulos detectados.

Para obter pré-requisitos e informações sobre como configurar o AWS Toolkit for Visual Studio, consulte Usando os [modelos AWS Lambda no Toolkit for Visual Studio AWS](lambda-index.md).

## Criar um projeto do Image Rekognition do Lambda do Visual Studio .NET Core
<a name="create-a-visual-studio-net-core-lam-image-rekognition-project"></a>

O procedimento a seguir descreve como criar uma aplicação do Lambda do Amazon Rekognition por meio do AWS Toolkit for Visual Studio.

**nota**  
Após a criação, sua aplicação terá uma solução com dois projetos: o projeto de origem, que contém o código da função do Lambda a ser implantado no Lambda, e um projeto de teste que usa o xUnit para testar a função localmente.  
Às vezes, o Visual Studio não consegue encontrar todas as NuGet referências para seus projetos. Isso ocorre porque os blueprints exigem dependências que devem ser recuperadas. NuGet Quando novos projetos são criados, o Visual Studio extrai apenas referências locais e não referências remotas de NuGet. Para corrigir NuGet erros: clique com o botão direito do mouse nas referências e escolha **Restaurar pacotes**.

1. No Visual Studio, expanda o menu **Arquivo**, expanda **Novo** e selecione **Projeto**.

1. Na caixa de diálogo **Novo projeto**, verifique se as caixas suspensas **Idioma**, **Plataforma** e **Tipo de projeto** estão definidas como “Todos…” e insira **aws lambda** no campo **Pesquisar**.

1. Selecione o modelo **AWS Lambda com testes (.NET Core - C\$1)**.

1. Clique em **Avançar** para abrir a caixa de diálogo **Configurar novo projeto**.

1. Na caixa de diálogo **Configurar seu novo projeto**, insira ImageRekognition "" como **Nome** e preencha os campos restantes de acordo com sua preferência. Clique no botão **Criar** para prosseguir até a caixa de diálogo **Selecionar esquema**.

1. Na caixa de diálogo **Selecionar esquema**, selecione o esquema **Detectar rótulos de imagens** e clique em **Concluir** para criar o projeto do Visual Studio.
**nota**  
Esse esquema fornece o código para escutar eventos do Amazon S3 e usa o Amazon Rekognition para detectar rótulos e adicioná-los ao objeto do S3 como tags.

## Revisar os arquivos de projeto
<a name="examine-the-files"></a>

As seções a seguir examinam esses arquivos de projeto:

1. `Function.cs`

1. `aws-lambda-tools-defaults.json`

### 1. Function.cs
<a name="functioncs"></a>

Dentro do arquivo `Function.cs`, o primeiro segmento do código é o atributo de conjunto, localizado na parte superior do arquivo. Por padrão, o Lambda só aceita parâmetros de entrada e tipos de retorno do tipo `System.IO.Stream`. Você deve registrar um serializador para usar classes tipadas para parâmetros de entrada e tipos de retorno. O atributo de conjunto registra o serializador JSON do Lambda, que usa `Newtonsoft.Json` para converter fluxos em classes tipadas. Você pode definir o serializador no nível de assembly ou método.

Veja a seguir um exemplo do atributo de conjunto:

```
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
```

A classe tem dois construtores. O primeiro é um construtor padrão usado quando o Lambda invoca a função. Esse construtor cria os clientes dos serviços Amazon S3 e Amazon Rekognition. O construtor também recupera AWS as credenciais desses clientes da função do IAM que você atribui à função ao implantá-la. A AWS região dos clientes é definida como a região em que sua função Lambda está sendo executada. Nesse esquema, você só deseja adicionar tags ao objeto do Amazon S3 caso o serviço Amazon Rekognition tenha um nível mínimo de confiança sobre o rótulo. Esse construtor verifica a variável de ambiente `MinConfidence` para determinar o nível de confiança aceitável. Você pode definir essa variável de ambiente ao implantar a função do Lambda.

Veja a seguir um exemplo do primeiro construtor de classe em `Function.cs`:

```
public Function()
{
    this.S3Client = new AmazonS3Client();
    this.RekognitionClient = new AmazonRekognitionClient();

    var environmentMinConfidence = System.Environment.GetEnvironmentVariable(MIN_CONFIDENCE_ENVIRONMENT_VARIABLE_NAME);
    if(!string.IsNullOrWhiteSpace(environmentMinConfidence))
    {
        float value;
        if(float.TryParse(environmentMinConfidence, out value))
        {
            this.MinConfidence = value;
            Console.WriteLine($"Setting minimum confidence to {this.MinConfidence}");
        }
        else
        {
            Console.WriteLine($"Failed to parse value {environmentMinConfidence} for minimum confidence. Reverting back to default of {this.MinConfidence}");
        }
    }
    else
    {
        Console.WriteLine($"Using default minimum confidence of {this.MinConfidence}");
    }
}
```

O exemplo a seguir demonstra como é possível utilizar o segundo construtor para testes. O projeto de teste configura os próprios clientes do S3 e do Rekognition e os passa:

```
public Function(IAmazonS3 s3Client, IAmazonRekognition rekognitionClient, float minConfidence)
{
    this.S3Client = s3Client;
    this.RekognitionClient = rekognitionClient;
    this.MinConfidence = minConfidence;
}
```

Veja a seguir um exemplo do método `FunctionHandler` dentro do arquivo `Function.cs`.

```
public async Task FunctionHandler(S3Event input, ILambdaContext context)
{
    foreach(var record in input.Records)
    {
        if(!SupportedImageTypes.Contains(Path.GetExtension(record.S3.Object.Key)))
        {
            Console.WriteLine($"Object {record.S3.Bucket.Name}:{record.S3.Object.Key} is not a supported image type");
            continue;
        }

        Console.WriteLine($"Looking for labels in image {record.S3.Bucket.Name}:{record.S3.Object.Key}");
        var detectResponses = await this.RekognitionClient.DetectLabelsAsync(new DetectLabelsRequest
        {
            MinConfidence = MinConfidence,
            Image = new Image
            {
                S3Object = new Amazon.Rekognition.Model.S3Object
                {
                    Bucket = record.S3.Bucket.Name,
                    Name = record.S3.Object.Key
                }
            }
        });

        var tags = new List();
        foreach(var label in detectResponses.Labels)
        {
            if(tags.Count < 10)
            {
                Console.WriteLine($"\tFound Label {label.Name} with confidence {label.Confidence}");
                tags.Add(new Tag { Key = label.Name, Value = label.Confidence.ToString() });
            }
            else
            {
                Console.WriteLine($"\tSkipped label {label.Name} with confidence {label.Confidence} because maximum number of tags reached");
            }
        }

        await this.S3Client.PutObjectTaggingAsync(new PutObjectTaggingRequest
        {
            BucketName = record.S3.Bucket.Name,
            Key = record.S3.Object.Key,
            Tagging = new Tagging
            {
                TagSet = tags
            }
        });
    }
    return;
}
```

 `FunctionHandler` é o método que o Lambda chamará depois de construir a instância. O parâmetro de entrada é do tipo `S3Event`, e não um `Stream`. Você pode fazer isso por causa do serializador JSON do Lambda registrado. O `S3Event` contém todas as informações sobre o evento acionado no Amazon S3. A função percorre todos os objetos do S3 que fizeram parte do evento e pede ao Rekognition para detectar rótulos. Depois que os rótulos forem detectados, eles serão adicionados como tags ao objeto do S3.

**nota**  
O código contém chamadas para `Console.WriteLine()`. Quando a função está em execução no Lambda, todas as chamadas são `Console.WriteLine()` redirecionadas para o Amazon Logs. CloudWatch 

### 2. aws-lambda-tools-defaults.json
<a name="toolsdefaults"></a>

O arquivo `aws-lambda-tools-defaults.json` contém valores padrão definidos pelo esquema para preencher previamente alguns dos campos no assistente de implantação. Também é útil para definir opções de linha de comandos para integração com a CLI do .NET Core.

Para acessar a integração da CLI do .NET Core, acesse o diretório do projeto da função e digite **dotnet lambda help**.

**nota**  
O manipulador da função indica qual método o Lambda deve chamar em resposta à função invocada. O formato desse campo é:`<assembly-name>::<full-type-name>::<method-name>`. O namespace deve ser incluído com o nome do tipo.

## Implantar a função
<a name="deploy-the-function"></a>

O procedimento a seguir descreve como implantar a função do Lambda.

1. **No **Solution Explorer**, clique com o botão direito do mouse no projeto Lambda e **escolha Publish to AWS Lambda para** abrir a janela Upload to. AWS Lambda**
**nota**  
Os valores predefinidos são recuperados do arquivo `aws-lambda-tools-defaults.json`.

1. Na janela **Fazer upload no AWS Lambda**, insira um nome no campo **Nome da função** e clique no botão **Próximo** para avançar até a janela **Detalhes avançados da função**.
**nota**  
Este exemplo usa o **Nome da função** **ImageRekognition**.  
![\[AWS Lambda function upload interface with package type, runtime, and configuration options.\]](http://docs.aws.amazon.com/pt_br/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-imgrek-03192024.png)

1. Na janela **Detalhes avançados da função**, selecione um perfil do IAM que conceda permissão ao seu código para acessar seus recursos do Amazon S3 e do Amazon Rekognition.
**nota**  
Se você estiver seguindo este exemplo, selecione o perfil `AWSLambda_FullAccess`.

1. Defina a variável de ambiente `MinConfidence` como 60 e selecione **Fazer upload** para iniciar o processo de implantação. O processo de publicação é concluído quando a visualização da **Função** é exibida no **AWS Explorer**.  
![\[AWS Lambda function configuration interface showing permissions, execution, and environment settings.\]](http://docs.aws.amazon.com/pt_br/toolkit-for-visual-studio/latest/user-guide/images/lambda-upload-imgrek-advanced-03192024.png)

1. Após a implantação bem-sucedida, configure o Amazon S3 a fim de enviar os eventos para a nova função. Para isso, acesse a guia **Origens de eventos**.

1. Na guia **Origens de eventos**, clique no botão **Adicionar** e selecione o bucket do Amazon S3 para conectar à sua função do Lambda.
**nota**  
O bucket deve estar na mesma AWS região da sua função Lambda.

## Testar a função do
<a name="test-the-function"></a>

Agora que a função está implantada e um bucket do S3 está configurado como uma fonte de eventos para ele, abra o navegador de buckets do S3 no **AWS Explorer** para o bucket selecionado por você. Em seguida, faça upload de algumas imagens.

Quando o upload estiver concluído, você poderá confirmar se a função foi executada observando os logs na visualização da função. Ou clique com o botão direito do mouse no navegador de buckets e escolha **Properties (Propriedades)**. Na guia **Tags**, você pode visualizar as tags que foram aplicadas ao objeto.

![\[Properties window showing metadata tags for an image file in a cloud storage bucket.\]](http://docs.aws.amazon.com/pt_br/toolkit-for-visual-studio/latest/user-guide/images/lambda-object-properties.png)