O [Guia de referência da API do AWS SDK para JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) descreve em detalhes todas as operações da API para o AWS SDK para JavaScript versão 3 (V3). 

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

# Trabalhe com AWS serviços no SDK para JavaScript
<a name="working-with-services"></a>

A AWS SDK para JavaScript v3 fornece acesso aos serviços aos quais oferece suporte por meio de uma coleção de classes de clientes. Com base nessas classes de clientes, você cria objetos de interface de serviço, comumente chamados de *objetos de serviço*. Cada AWS serviço suportado tem uma ou mais classes de clientes que oferecem baixo nível de uso APIs de recursos e recursos de serviço. Por exemplo, o Amazon APIs DynamoDB está disponível por meio da classe. `DynamoDB`

Os serviços expostos por meio do SDK JavaScript seguem o padrão de solicitação-resposta para trocar mensagens com aplicativos de chamada. Nesse padrão, o código que invoca um serviço envia uma HTTP/HTTPS solicitação para um endpoint do serviço. A solicitação contém os parâmetros necessários para invocar com sucesso o recurso específico que está sendo chamado. O serviço que é invocado gera uma resposta, que é enviada de volta ao solicitante. A resposta contém dados, caso a operação tenha tido sucesso, ou informações de erro, caso a operação não tenha tido sucesso. 

A invocação AWS de um serviço inclui todo o ciclo de vida de solicitação e resposta de uma operação em um objeto de serviço, incluindo qualquer tentativa de nova tentativa. Uma solicitação contém zero ou mais propriedades como parâmetros JSON. A resposta é encapsulada em um objeto relacionado à operação e é retornada ao solicitante por meio de uma das várias técnicas, como uma função de retorno de chamada ou uma promessa. JavaScript 

**Topics**
+ [Criar e chamar objetos de serviço](creating-and-calling-service-objects.md)
+ [Chamar serviços assincronamente](calling-services-asynchronously.md)
+ [Criar solicitações de clientes de serviço](the-request-object.md)
+ [Lidar com as respostas do cliente de serviço](the-response-object.md)
+ [Trabalhar com JSON](working-with-json.md)
+ [Registrando AWS SDK para JavaScript chamadas](logging-sdk-calls.md)
+ [Use endpoints AWS baseados em contas com o DynamoDB](ddb-account-based-endpoints-v3.md)
+ [Proteção da integridade de dados com as somas de verificação do Amazon S3](s3-checksums.md)
+ [SDK para exemplos de JavaScript código](sdk-code-samples.md)

# Criar e chamar objetos de serviço
<a name="creating-and-calling-service-objects"></a>

A JavaScript API é compatível com a maioria dos AWS serviços disponíveis. Cada serviço na JavaScript API fornece a uma classe de cliente um `send` método que você usa para invocar todas as APIs suportadas pelo serviço. Para obter mais informações sobre classes de serviço, operações e parâmetros na JavaScript API, consulte a [Referência da API](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/).

Ao usar o SDK no Node.js, você adiciona o pacote do SDK para cada serviço de que precisa para seu aplicativo usando `import`, que fornece suporte a todos os serviços atuais. O exemplo a seguir cria um objeto de recurso do Amazon S3 na Região `us-west-1`.

```
// Import the Amazon S3 service client
import { S3Client } from "@aws-sdk/client-s3"; 
// Create an S3 client in the us-west-1 Region
const s3Client = new S3Client({
    region: "us-west-1"
});
```

## Especificar os parâmetros do objeto de serviço
<a name="specifying-service-object-parameters"></a>

Ao chamar um método de um objeto de serviço, passe os parâmetros em JSON, conforme exigido pela API. Por exemplo, no Amazon S3, para obter um objeto para o bucket e a chave especificados, passe os parâmetros a seguir para o método `GetObjectCommand` do `S3Client`. Para obter mais informações sobre como passar os parâmetros JSON, consulte [Trabalhar com JSON](working-with-json.md).

```
s3Client.send(new GetObjectCommand({Bucket: 'bucketName', Key: 'keyName'}));
```

Para obter mais informações sobre parâmetros do Amazon S3, consulte [@aws-sdk/client-s3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-s3/) na Referência da API.

## Use @smithy /types para clientes gerados em TypeScript
<a name="smithy-types"></a>

Se você estiver usando TypeScript, o `@smithy/types` pacote permite manipular as formas de entrada e saída de um cliente.

### Cenário: remover `undefined` das estruturas de entrada e saída
<a name="remove-undefined-from-input"></a>

Os membros das formas geradas são unidos às formas `undefined` de entrada e são `?` (opcional) às formas de saída. Para entradas, isso adia a validação para o serviço. Para saídas, isso sugere fortemente que você deve verificar os dados de saída em runtime.

Se você quiser pular essas etapas, use os auxiliares de tipo `AssertiveClient` ou `UncheckedClient`. O exemplo a seguir usa os auxiliares de tipo com o serviço Amazon S3.

```
import { S3 } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient } from "@smithy/types";

const s3a = new S3({}) as AssertiveClient<S3>;
const s3b = new S3({}) as UncheckedClient<S3>;

// AssertiveClient enforces required inputs are not undefined
// and required outputs are not undefined.
const get = await s3a.getObject({
  Bucket: "",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
});

// UncheckedClient makes output fields non-nullable.
// You should still perform type checks as you deem
// necessary, but the SDK will no longer prompt you
// with nullability errors.
const body = await (
  await s3b.getObject({
    Bucket: "",
    Key: "",
  })
).Body.transformToString();
```

Ao usar a transformação em um cliente não agregado com a sintaxe `Command`, a entrada não pode ser validada porque passa por outra classe, conforme mostrado no exemplo abaixo.

```
import { S3Client, ListBucketsCommand, GetObjectCommand, GetObjectCommandInput } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient, NoUndefined } from "@smithy/types";

const s3 = new S3Client({}) as UncheckedClient<S3Client>;

const list = await s3.send(
  new ListBucketsCommand({
    // command inputs are not validated by the type transform.
    // because this is a separate class.
  })
);

/**
 * Although less ergonomic, you can use the NoUndefined<T>
 * transform on the input type.
 */
const getObjectInput: NoUndefined<GetObjectCommandInput> = {
  Bucket: "undefined",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
  // optional params can still be undefined.
  SSECustomerAlgorithm: undefined,
};

const get = s3.send(new GetObjectCommand(getObjectInput));

// outputs are still transformed.
await get.Body.TransformToString();
```

### Cenário: restringir os tipos de blob de carga útil de saída de um cliente TypeScript gerado pelo Smithy
<a name="remove-undefined-from-input"></a>

Esse cenário é relevante principalmente para operações com corpos de streaming, como `S3Client` na AWS SDK para JavaScript v3.

Como os tipos de blob de carga útil dependem da plataforma, indique em seu aplicativo que um cliente está sendo executado em um ambiente específico. Isso restringe os tipos de blob de carga útil conforme mostrado no exemplo a seguir.

```
import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
import type { NodeJsClient, SdkStream, StreamingBlobPayloadOutputTypes } from "@smithy/types";
import type { IncomingMessage } from "node:http";

// default client init.
const s3Default = new S3Client({});

// client init with type narrowing.
const s3NarrowType = new S3Client({}) as NodeJsClient<S3Client>;

// The default type of blob payloads is a wide union type including multiple possible
// request handlers.
const body1: StreamingBlobPayloadOutputTypes = (await s3Default.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;

// This is of the narrower type SdkStream<IncomingMessage> representing
// blob payload responses using specifically the node:http request handler.
const body2: SdkStream<IncomingMessage> = (await s3NarrowType.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;
```

# Chamar serviços assincronamente
<a name="calling-services-asynchronously"></a>

Todas as solicitações feitas por meio do SDK são assíncronas. É importante ter isso em mente ao escrever scripts de navegador. JavaScript a execução em um navegador da Web normalmente tem apenas um único thread de execução. Depois de fazer uma chamada assíncrona para um AWS serviço, o script do navegador continua em execução e, no processo, pode tentar executar o código que depende desse resultado assíncrono antes que ele retorne.

Fazer chamadas assíncronas para um AWS serviço inclui gerenciar essas chamadas para que seu código não tente usar dados antes que eles estejam disponíveis. Os tópicos desta seção explicam a necessidade de gerenciar chamadas assíncronas e detalha diferentes técnicas que você pode usar para gerenciá-las.

Embora você possa usar qualquer uma dessas técnicas para gerenciar chamadas assíncronas, recomendamos que você use async/await para todos os novos códigos.

async/await  
Recomendamos que você use essa técnica, pois é o comportamento padrão na V3.

promise  
Use essa técnica em navegadores que não são compatíveis com async/await.

callback  
Evite usar callbacks, exceto em casos muito simples. No entanto, você pode achar que é útil para cenários de migração.

**Topics**
+ [Gerenciar chamadas assíncronas](making-asynchronous-calls.md)
+ [Usar async/await](using-async-await.md)
+ [Use JavaScript promessas](using-promises.md)
+ [Usar uma função de retorno de chamada anônima](using-a-callback-function.md)

# Gerenciar chamadas assíncronas
<a name="making-asynchronous-calls"></a>

Por exemplo, a página inicial de um site de comércio eletrônico permite que os clientes que retornam façam login. Parte do benefício para os clientes que fazem login é que, depois de fazerem-no, o site se personaliza de acordo com suas preferências específicas. Para fazer isso acontecer:

1. O cliente deve fazer login e ser validado com suas credenciais de login.

1. As preferências do cliente são solicitadas a banco de dados de clientes.

1. O banco de dados fornece as preferências do cliente, que são usadas para personalizar o site antes que a página carregue.

Se essas tarefas forem executadas de forma síncrona, cada uma delas deverá terminar antes de a seguinte começar. A página da Web não terminaria de carregar até que as preferências do cliente fossem apresentadas pelo banco de dados. No entanto, após a consulta de banco de dados ser enviada ao servidor, o recebimento dos dados do cliente pode ser atrasado ou até mesmo falhar devido a gargalos da rede, tráfego excepcionalmente alto no banco de dados ou conexão ruim nos dispositivos móveis.

Para evitar que o site congele sob essas condições, chame o banco de dados de forma assíncrona. Depois de a chamada do banco de dados ser executada, enviando sua solicitação assíncrona, o código continuará a ser executado conforme o esperado. Se você não gerir adequadamente a resposta de uma chamada assíncrona, o código poderá tentar usar informações que espera de volta do banco de dados quando esses dados ainda não estiverem disponíveis.

![\[Mostrando a diferença entre a execução síncrona e a execução assíncrona.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/async-vs-sync.png)


# Usar async/await
<a name="using-async-await"></a>

Em vez de usar promessas, considere o uso de async/await. As funções assíncronas são mais simples e usam menos boilerplate do que as promessas. Await só pode ser usado em uma função assíncrona para esperar assincronamente um valor.

O exemplo a seguir é usado async/await para listar todas as suas tabelas do Amazon DynamoDB em. ` us-west-2`

**nota**  
Para executar este exemplo:  
Instale o AWS SDK para JavaScript cliente do DynamoDB `npm install @aws-sdk/client-dynamodb` entrando na linha de comando do seu projeto.
Verifique se você configurou suas AWS credenciais corretamente. Para obter mais informações, consulte [Definir credenciais](setting-credentials.md). 

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
(async function () {
  const dbClient = new DynamoDBClient({ region: "us-west-2" });
  const command = new ListTablesCommand({});

  try {
    const results = await dbClient.send(command);
    console.log(results.TableNames.join('\n'));
  } catch (err) {
    console.error(err)
  }
})();
```

**nota**  
 Nem todos os navegadores oferecem suporte para async/await. Consulte [Funções assíncronas](https://caniuse.com/#feat=async-functions) para obter uma lista de navegadores com async/await suporte. 

# Use JavaScript promessas
<a name="using-promises"></a>

Use o método AWS SDK para JavaScript v3 (`ListTablesCommand`) do cliente de serviço para fazer a chamada de serviço e gerenciar o fluxo assíncrono em vez de usar retornos de chamada. O exemplo a seguir mostra como obter os nomes de tabelas do Amazon DynamoDB em `us-west-2`.

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
const dbClient = new DynamoDBClient({ region: 'us-west-2' });

dbClient.listtables(new ListTablesCommand({}))
  .then(response => {
    console.log(response.TableNames.join('\n'));
  })
  .catch((error) => {
    console.error(error);
  });
```

## Coordenar várias promessas
<a name="multiple-promises"></a>

Em algumas situações, seu código deve fazer várias chamadas assíncronas que exigem ação somente quando todos tiverem sido retornados com êxito. Se você gerenciar as chamadas individuais do método assíncrono com promessas, pode criar uma promessa adicional que usa o método `all`. 

Esse método cumpre essa promessa generalista se, e quando, a série de promessas que você passar para o método forem cumpridas. A função de retorno de chamada é transmitida a um array dos valores das promessas passadas para o método `all`.

No exemplo a seguir, uma AWS Lambda função deve fazer três chamadas assíncronas para o Amazon DynamoDB, mas só pode ser concluída depois que as promessas de cada chamada forem cumpridas.

```
const values = await Promise.all([firstPromise, secondPromise, thirdPromise]);

console.log("Value 0 is " + values[0].toString);
console.log("Value 1 is " + values[1].toString);
console.log("Value 2 is " + values[2].toString);

return values;
```

## Suporte de navegador e Node.js para promessas
<a name="browser-node-promise-support"></a>

Support for JavaScript native promise (ECMAScript 2015) depende do JavaScript mecanismo e da versão em que seu código é executado. Para ajudar a determinar o suporte para JavaScript promessas em cada ambiente em que seu código precisa ser executado, consulte a [tabela de ECMAScript compatibilidade](https://compat-table.github.io/compat-table/es6/) em GitHub.

# Usar uma função de retorno de chamada anônima
<a name="using-a-callback-function"></a>

Cada método de objeto de serviço pode aceitar uma função de retorno de chamada anônima como o último parâmetro. A assinatura dessa função de retorno de chamada é:

```
function(error, data) {
    // callback handling code
};
```

Essa função de retorno de chamada é executada ao se retornar uma resposta bem-sucedida ou dados de erro. Se a chamada do método for bem-sucedida, o conteúdo da resposta estará disponível para a função de retorno de chamada no parâmetro `data`. Se a chamada não for bem-sucedida, os detalhes sobre a falha são fornecidos no parâmetro `error`.

Normalmente o código dentro da função de retorno de chamada testa um erro, que ele processa, caso seja retornado um erro. Se o erro não for retornado, o código recuperará os dados na resposta pelo parâmetro `data`. O formato básico da função de retorno de chamada é semelhante a este exemplo.

```
function(error, data) {
    if (error) {
        // error handling code
        console.log(error);
    } else {
        // data handling code
        console.log(data);
    }
};
```

No exemplo anterior, os detalhes do erro ou dos dados retornados são registrados no console. Veja a seguir um exemplo que mostra uma função de retorno de chamada passada como parte da chamada de um método em um objeto de serviço.

```
ec2.describeInstances(function(error, data) {
  if (error) {
    console.log(error); // an error occurred
  } else {
    console.log(data); // request succeeded
  }
});
```

# Criar solicitações de clientes de serviço
<a name="the-request-object"></a>

Fazer solicitações aos clientes AWS de atendimento é simples. A versão 3 (V3) do SDK JavaScript permite que você envie solicitações. 

**nota**  
Você também pode realizar operações usando os comandos da versão 2 (V2) ao usar a V3 do SDK para. JavaScript Para obter mais informações, consulte [Usar comandos da v2](migrating.md#using_v2_commands).

**Para enviar uma solicitação:**

1. Inicialize um objeto cliente com a configuração desejada, como uma Região da AWS específica.

1. (Opcional) Crie um objeto JSON de solicitação com os valores da solicitação, como o nome de um bucket específico do Amazon S3. Você pode examinar os parâmetros da solicitação consultando o tópico Referência da API referente à interface com o nome associado ao método do cliente. Por exemplo, se você usar o método *AbcCommand* client, a interface de solicitação será*AbcInput*.

1. Inicialize um comando de serviço, opcionalmente, com o objeto de solicitação como entrada.

1. Chame `send` no cliente com o objeto de comando como entrada.

Por exemplo, para listar suas tabelas do Amazon DynamoDB em `us-west-2`, você pode fazer isso com async/await.

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";

(async function () {
  const dbClient = new DynamoDBClient({ region: 'us-west-2' });
  const command = new ListTablesCommand({});

  try {
    const results = await dbClient.send(command);
    console.log(results.TableNames.join('\n'));
  } catch (err) {
    console.error(err);
  }
})();
```

# Lidar com as respostas do cliente de serviço
<a name="the-response-object"></a>

Depois que um método de cliente de serviço foi chamado, ele retorna uma instância do objeto de resposta de uma interface com o nome associado ao método de cliente. Por exemplo, se você usar o método * AbcCommand* client, o objeto de resposta será do tipo *AbcResponse* (interface).

## Acessar dados retornados na resposta
<a name="response-data-property"></a>

O objeto de resposta contém os dados, como propriedades, retornados pela solicitação de serviço.

Em [Criar solicitações de clientes de serviço](the-request-object.md), o comando ` ListTablesCommand` retornou os nomes de tabela na propriedade `TableNames` da resposta.

## Acessar informações de erro
<a name="response-error-property"></a>

Se um comando falhar, causará uma exceção. O código de erro a seguir mostra uma forma de lidar com uma exceção de serviço.

```
try {
  await client.send(someCommand);
} catch (e) {
  if (e.name === "InvalidSignatureException") {
    // Handle InvalidSignatureException
  } else if (e.name === "ResourceNotFoundException") {
    // Handle ResourceNotFoundException
  } else if (e.name === "FooServiceException") {
    // Handle all other server-side exceptions from Foo service
  } else {
    // Handle errors from SDK
  }
}
```

# Trabalhar com JSON
<a name="working-with-json"></a>

JSON é um formato de intercâmbio de dados capaz de ser lido por humanos e por máquina. Embora o nome JSON seja um acrônimo para *JavaScript Object Notation*, o formato do JSON é independente de qualquer linguagem de programação.

O AWS SDK para JavaScript usa JSON para enviar dados para objetos de serviço ao fazer solicitações e recebe dados de objetos de serviço como JSON. Para mais informações sobre JSON, consulte [json.org](https://json.org).

![\[Como mostrar o formato geral e partes do JSON.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/json-format.png)


JSON representa dados de duas formas:
+ Um *objeto*, que é uma coleção não ordenada de pares de nome/valor. Um objeto é definido dentro das chaves esquerda (`{`) e direita (`}`). Cada par de nome e valor começa com o nome seguido por uma vírgula seguido pelo valor. O pares de nome/valor são separados por vírgulas.
+ Um *array*, que é uma coleção ordenada de valores. Um array é definido dentro dos colchetes esquerdo (`[`) e direito (`]`). Os itens no array são separados por vírgulas.

Aqui está um exemplo de um objeto JSON que contém um array de objetos em que os objetos representam as cartas de um baralho. Cada carta é definida por dois pares de nome/valor: um que especifica um valor exclusivo para identificar que essa carta e outro que especifica um URL que aponta para a imagem da carta correspondente.

```
var cards = [
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"}
];
```

## JSON como parâmetros do objeto de serviço
<a name="json-as-parameters-passed"></a>

Veja a seguir um exemplo de JSON simples usado para definir os parâmetros de uma chamada para um objeto de serviço do AWS Lambda .

```
const params = {
   FunctionName : funcName,
   Payload : JSON.stringify(payload),
   LogType : LogType.Tail,
};
```

O objeto `params` é definido por três pares de nome/valor, separados por vírgulas, dentro das chaves esquerda e direita. Ao fornecer parâmetros para uma chamada do método do objeto de serviço, os nomes são determinados pelos nomes de parâmetro do método do objeto de serviço que você pretende chamar. Ao invocar uma função do Lambda, `FunctionName`, `Payload` e ` LogType` são os parâmetros usados para chamar o método `invoke` em um objeto de serviço do Lambda.

Ao passar os parâmetros para uma chamada do método do objeto de serviço, forneça o objeto JSON para a chamada de método, conforme mostrado no exemplo a seguir de como invocar uma função do Lambda.

```
const invoke = async (funcName, payload) => {
  const client = new LambdaClient({});
  const command = new InvokeCommand({
    FunctionName: funcName,
    Payload: JSON.stringify(payload),
    LogType: LogType.Tail,
  });

  const { Payload, LogResult } = await client.send(command);
  const result = Buffer.from(Payload).toString();
  const logs = Buffer.from(LogResult, "base64").toString();
  return { logs, result };
};
```

# Registrando AWS SDK para JavaScript chamadas
<a name="logging-sdk-calls"></a>

O AWS SDK para JavaScript é instrumentado com um registrador integrado para que você possa registrar as chamadas de API feitas com o SDK para. JavaScript

Para ativar o registrador e imprimir entradas de registro no console, configure o cliente de serviço usando o parâmetro opcional `logger`. O exemplo abaixo habilita o registro do cliente enquanto ignora as saídas de rastreamento e depuração.

```
new S3Client({
  logger: {
    ...console,
    debug(...args) {},
    trace(...args) {},
  },
});
```

## Usar um middleware para registrar solicitações
<a name="middleware-logger"></a>

O AWS SDK para JavaScript usa uma pilha de middleware para controlar o ciclo de vida de uma chamada de operação. Cada middleware na pilha chama o próximo middleware após fazer qualquer alteração no objeto de solicitação. Isso também facilita a depuração de problemas na pilha, porque você pode ver exatamente qual middleware foi chamado antes de um erro. Veja o seguinte exemplo de solicitações de registro em log usando um middleware:

```
const client = new DynamoDB({ region: "us-west-2" });

client.middlewareStack.add(
  (next, context) => async (args) => {
    console.log("AWS SDK context", context.clientName, context.commandName);
    console.log("AWS SDK request input", args.input);
    const result = await next(args);
    console.log("AWS SDK request output:", result.output);
    return result;
  },
  {
    name: "MyMiddleware",
    step: "build",
    override: true,
  }
);

await client.listTables({});
```

No exemplo acima, um middleware é adicionado à pilha de middleware do cliente DynamoDB. O primeiro argumento é uma função que aceita `next`, o próximo middleware na pilha a ser chamado, e `context`, um objeto que contém algumas informações sobre a operação que está sendo chamada. Ele retorna uma função que aceita `args`, um objeto que contém os parâmetros passados para a operação e a solicitação, e retorna o resultado da chamada do próximo middleware com `args`.

# Use endpoints AWS baseados em contas com o DynamoDB
<a name="ddb-account-based-endpoints-v3"></a>

O DynamoDB [AWS oferece endpoints baseados em contas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints) que podem melhorar o desempenho usando AWS seu ID de conta para simplificar o roteamento de solicitações. 

Para aproveitar esse recurso, use a versão 3.656.0 ou superior do AWS SDK para JavaScript versão 3. Esse recurso de endpoints baseados em contas é habilitado por padrão nesta nova versão.

Se quiser optar por não utilizar o roteamento baseado em contas, você terá as seguintes opções:
+ Configurar um cliente de serviço do DynamoDB com o parâmetro `accountIdEndpointMode` definido como `disabled`.
+ Definir a variável de ambiente `AWS_ACCOUNT_ID_ENDPOINT_MODE` como `disabled`.
+ Atualize a AWS configuração do arquivo de configuração compartilhado `account_id_endpoint_mode` para`disabled`.

O seguinte trecho é um exemplo de como desabilitar o roteamento baseado em contas configurando um cliente de serviço do DynamoDB:

```
const ddbClient = new DynamoDBClient({
  region: "us-west-2",
  accountIdEndpointMode: "disabled" // Disable account ID in the endpoint
});
```

O Guia de referência de ferramentas AWS SDKs e ferramentas fornece mais informações sobre as [outras opções de configuração](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html).

# Proteção da integridade de dados com as somas de verificação do Amazon S3
<a name="s3-checksums"></a>

O Amazon Simple Storage Service (Amazon S3) oferece a capacidade de especificar uma soma de verificação ao fazer upload de um objeto. Quando você especifica uma soma de verificação, ela é armazenada com o objeto e pode ser validada quando o objeto é baixado.

As somas de verificação fornecem uma camada adicional de integridade de dados quando você transfere arquivos. Com somas de verificação, você pode verificar a consistência de dados confirmando que o arquivo recebido corresponde ao arquivo original. Para obter mais informações sobre as somas de verificação no Amazon S3, consulte o [Guia do usuário do Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html), incluindo os [algoritmos compatíveis](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums).

Você tem a flexibilidade de escolher o algoritmo mais adequado às suas necessidades e deixar que o SDK calcule a soma de verificação. Como alternativa, você pode fornecer um valor de soma de verificação pré-computado usando um dos algoritmos compatíveis.

**nota**  
A partir da versão 3.729.0 do AWS SDK para JavaScript, o SDK fornece proteções de integridade padrão calculando automaticamente uma soma de verificação `CRC32` para uploads. O SDK calcula essa soma de verificação se você não fornecer um valor de soma de verificação pré-calculado ou se não especificar um algoritmo que o SDK deva usar para calcular uma soma de verificação.  
O SDK também fornece configurações globais para proteções de integridade de dados que você pode definir externamente, sobre as quais você pode ler no Guia de referência de [ferramentas AWS SDKs e ferramentas](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html).

## Fazer upload de um objeto
<a name="use-service-S3-checksum-upload"></a>

Você carrega objetos para o Amazon S3 usando o [PutObject](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectCommand/)comando do. `S3Client` Use o parâmetro `ChecksumAlgorithm` do construtor do `PutObjectRequest` para habilitar o cálculo da soma de verificação e especificar o algoritmo. Consulte os [algoritmos de soma de verificação compatíveis](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums) para obter os valores válidos.

O trecho de código a seguir mostra uma solicitação para carregar um objeto com uma soma de verificação CRC-32. Quando o SDK envia a solicitação, ele calcula a soma de verificação CRC-32 e carrega o objeto. O Amazon S3 armazena a soma de verificação com o objeto.

```
import { ChecksumAlgorithm, S3 } from "@aws-sdk/client-s3";

const client = new S3();
const response = await client.putObject({
  Bucket: "my-bucket",
  Key: "my-key",
  Body: "Hello, world!",
  ChecksumAlgorithm: ChecksumAlgorithm.CRC32,
});
```

Se você não fornecer um algoritmo de soma de verificação na solicitação, o comportamento da soma de verificação varia conforme a versão do SDK utilizado, conforme mostrado na tabela a seguir.

**Comportamento da soma de verificação quando nenhum algoritmo de soma de verificação é fornecido**


| SDK para a versão JavaScript  | Comportamento da soma de verificação | 
| --- | --- | 
| Anterior a 3.729.0 | O SDK não calcula automaticamente uma soma de verificação baseada em CRC e a fornece na solicitação. | 
| 3.729.0 ou posterior | O SDK usa o algoritmo CRC32 para calcular a soma de verificação e a fornece na solicitação. O Amazon S3 valida a integridade da transferência computando sua própria soma de verificação CRC32 e a compara com a soma de verificação fornecida pelo SDK. Se as somas de verificação corresponderem, a soma de verificação será salva com o objeto. | 

Se a soma de verificação calculada pelo SDK não corresponder à soma de verificação calculada pelo Amazon S3 ao receber a solicitação, um erro será retornado.

### Usar um valor de soma de verificação pré-calculado
<a name="use-service-S3-checksum-upload-pre"></a>

Um valor de soma de verificação pré-calculado fornecido com a solicitação desabilita a computação automática pelo SDK e, em vez disso, usa o valor fornecido.

O exemplo a seguir mostra uma solicitação com uma soma de verificação SHA-256 pré-calculada.

```
import { S3 } from "@aws-sdk/client-s3";
import { createHash } from "node:crypto";

const client = new S3();

const Body = "Hello, world!";
const ChecksumSHA256 = await createHash("sha256").update(Body).digest("base64");

const response = await client.putObject({
  Bucket: "my-bucket",
  Key: "my-key",
  Body,
  ChecksumSHA256,
});
```

Se o Amazon S3 determinar que o valor da soma de verificação está incorreto para o algoritmo especificado, o serviço retornará uma resposta de erro.

### Carregamentos fracionados
<a name="use-service-S3-checksum-upload-multi"></a>

Você também pode usar somas de verificação com carregamentos fracionados. Eles AWS SDK para JavaScript podem usar as opções da `Upload` biblioteca `@aws-sdk/lib-storage` para usar somas de verificação com uploads de várias partes.

```
import { ChecksumAlgorithm, S3 } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import { createReadStream } from "node:fs";

const client = new S3();
const filePath = "/path/to/file";
const Body = createReadStream(filePath);

const upload = new Upload({
  client,
  params: {
    Bucket: "my-bucket",
    Key: "my-key",
    Body,
    ChecksumAlgorithm: ChecksumAlgorithm.CRC32,
  },
});
await upload.done();
```

# SDK para exemplos de JavaScript código
<a name="sdk-code-samples"></a>

Os tópicos desta seção contêm exemplos de como usar o AWS SDK para JavaScript com APIs os vários serviços para realizar tarefas comuns.

Encontre o código-fonte desses e de outros exemplos no [Repositório de exemplos de AWS código em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples). Para propor um novo exemplo de código para a equipe de AWS documentação considerar a produção, crie uma solicitação. A equipe está buscando produzir exemplos de código que abrangem cenários e casos de uso mais amplos, em vez de trechos de código simples que abrangem apenas chamadas de API individuais. Para obter instruções, consulte a seção *Código de autoria* nas [diretrizes de contribuição em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md).

**Importante**  
Esses exemplos usam a sintaxe de ECMAScript6 importação/exportação.   
Isso requer o Node.js versão 14.17 ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md) para obter as diretrizes de conversão.

**Topics**
+ [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md)
+ [AWS Elemental MediaConvertExemplos da](emc-examples.md)
+ [AWS LambdaExemplos da](lambda-examples.md)
+ [Exemplos do Amazon Lex](lex-examples.md)
+ [Exemplos do Amazon Polly](polly-examples.md)
+ [Exemplos do Amazon Redshift](redshift-examples.md)
+ [Exemplos do Amazon Simple Email Service](ses-examples.md)
+ [Exemplos do Amazon Simple Notification Service](sns-examples.md)
+ [Exemplos do Amazon Transcribe](Transcribe-examples.md)
+ [Configuração do Node.js em uma instância do Amazon EC2](setting-up-node-on-ec2-instance.md)
+ [Invocar o Lambda com o API Gateway](api-gateway-invoking-lambda-example.md)
+ [Criação de eventos agendados para executar AWS Lambda funções](scheduled-events-invoking-lambda-example.md)
+ [Criar um chatbot do Amazon Lex](lex-bot-example.md)

# Sintaxe ES6/CommonJS de JavaScript
<a name="sdk-example-javascript-syntax"></a>

Os exemplos de código do AWS SDK para JavaScript são escritos em ECMAScript 6 (ES6). O ES6 apresenta nova sintaxe e novos atributos para tornar seu código mais moderno e legível, e muito mais. 

O ES6 requer que você use o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download). Entretanto, se você preferir, poderá converter qualquer um dos nossos exemplos em sintaxe CommonJS usando as seguintes diretrizes:
+ Remova `"type" : "module"` do `package.json` no ambiente do projeto.
+ Converta todas as instruções `import` de ES6 em instruções `require` de CommonJS. Por exemplo, converta:

  ```
  import { CreateBucketCommand } from "@aws-sdk/client-s3";
  import { s3 } from "./libs/s3Client.js";
  ```

  Em seu equivalente de CommonJS:

  ```
  const { CreateBucketCommand } = require("@aws-sdk/client-s3");
  const { s3 } = require("./libs/s3Client.js");
  ```
+ Converta todas as instruções `export` de ES6 em instruções `module.exports` de CommonJS. Por exemplo, converta:

  ```
  export {s3}
  ```

  Em seu equivalente de CommonJS:

  ```
  module.exports = {s3}
  ```

O exemplo a seguir demonstra o exemplo de código para criar um bucket do Amazon S3 em ES6 e CommonJS.

------
#### [ ES6 ]

libs/s3Client.js

```
// Create service client module using ES6 syntax.
import { S3Client } from "@aws-sdk/client-s3";
// Set the AWS region
const REGION = "eu-west-1"; //e.g. "us-east-1"
// Create Amazon S3 service object.
const s3 = new S3Client({ region: REGION });
// Export 's3' constant.
export {s3};
```

s3\$1createbucket.js

```
// Get service clients module and commands using ES6 syntax.
 import { CreateBucketCommand } from "@aws-sdk/client-s3";
 import { s3 } from "./libs/s3Client.js";

// Get service clients module and commands using CommonJS syntax.
// const { CreateBucketCommand } = require("@aws-sdk/client-s3");
// const { s3 } = require("./libs/s3Client.js");

// Set the bucket parameters
const bucketParams = { Bucket: "BUCKET_NAME" };

// Create the Amazon S3 bucket.
const run = async () => {
  try {
    const data = await s3.send(new CreateBucketCommand(bucketParams));
    console.log("Success", data.Location);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------
#### [ CommonJS ]

libs/s3Client.js

```
// Create service client module using CommonJS syntax.
 const { S3Client } = require("@aws-sdk/client-s3");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
 // Create Amazon S3 service object.
const s3 = new S3Client({ region: REGION });
// Export 's3' constant.
 module.exports ={s3};
```

s3\$1createbucket.js

```
// Get service clients module and commands using CommonJS syntax.
const { CreateBucketCommand } = require("@aws-sdk/client-s3");
const { s3 } = require("./libs/s3Client.js");

// Set the bucket parameters
const bucketParams = { Bucket: "BUCKET_NAME" };

// Create the Amazon S3 bucket.
const run = async () => {
  try {
    const data = await s3.send(new CreateBucketCommand(bucketParams));
    console.log("Success", data.Location);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------

# AWS Elemental MediaConvertExemplos da
<a name="emc-examples"></a>

AWS Elemental MediaConvertO é um serviço de transcodificação de vídeo baseado em arquivo com recursos de nível de transmissão. Você pode usá-lo para criar ativos para fornecer transmissão e vídeo sob demanda (VoD) na Internet. Para obter mais informações, consulte o [https://docs.aws.amazon.com/mediaconvert/latest/ug/](https://docs.aws.amazon.com/mediaconvert/latest/ug/).

A API JavaScript para MediaConvert é exposta por meio da classe de cliente do `MediaConvert`. Para obter mais informações, consulte [Classe: MediaConvert](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/) na Referência da API.

**Topics**
+ [Criar e gerenciar tarefas de transcodificação no MediaConvert](emc-examples-jobs.md)
+ [Uso de modelos de trabalho no MediaConvert](emc-examples-templates.md)

# Criar e gerenciar tarefas de transcodificação no MediaConvert
<a name="emc-examples-jobs"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como criar tarefas de transcodificação no MediaConvert.
+ Como cancelar uma tarefa de transcodificação.
+ Como recuperar o JSON para concluir uma tarefa de transcodificação.
+ Como recuperar uma matriz JSON para até 20 das tarefas criadas mais recentemente.

## O cenário
<a name="emc-examples-jobs-scenario"></a>

Neste exemplo, você usa um módulo Node.js a fim de chamar o MediaConvert para criar e gerenciar tarefas de transcodificação. O código usa o SDK para JavaScript para fazer isso usando estes métodos da classe de cliente do MediaConvert:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/)

## Tarefas de pré-requisito
<a name="emc-examples-jobs-prerequisites"></a>

Para configurar e executar este exemplo, primeiro conclua estas tarefas:
+ Configure o ambiente do projeto para executar estes exemplos do Node TypeScript e instale os módulos do AWS SDK para JavaScript e de terceiros necessários. Siga as instruções no [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no *Guia de referência de ferramentas e SDKs da AWS*.
+ Crie e configure buckets do Amazon S3 que forneçam armazenamento para arquivos de entrada e de saída da tarefa. Para obter detalhes, consulte [Criar armazenamento para arquivos](https://docs.aws.amazon.com/mediaconvert/latest/ug/set-up-file-locations.html) no *Guia do usuário do AWS Elemental MediaConvert*.
+ Faça upload do vídeo de entrada no bucket do Amazon S3 provisionado para armazenamento de entrada. Para obter uma lista dos codecs de vídeo de entrada e contêineres compatíveis, consulte [Codecs e contêineres de entrada compatíveis](https://docs.aws.amazon.com/mediaconvert/latest/ug/reference-codecs-containers-input.html) no *Guia do usuário do AWS Elemental MediaConvert*.
+ Crie um perfil do IAM que dê ao MediaConvert acesso aos arquivos de entrada e aos buckets do Amazon S3 onde os arquivos de saída são armazenados. Para obter detalhes, consulte [Configurar permissões do IAM](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) no *Guia do usuário do AWS Elemental MediaConvert*.

**Importante**  
Este exemplo usa ECMAScript6 (ES6). Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).  
No entanto, se você preferir usar a sintaxe CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Definição de um trabalho de transcodificação simples
<a name="emc-examples-jobs-spec"></a>

Crie um módulo do Node.js com o nome de arquivo `emc_createjob.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie o JSON que define os parâmetros da tarefa de transcodificação.

Esses parâmetros são bem detalhados. Você pode usar o [console do AWS Elemental MediaConvert](https://console.aws.amazon.com/mediaconvert/) para gerar os parâmetros de trabalho do JSON escolhendo as configurações de tarefa no console e depois selecionando **Mostrar JSON de trabalho** na parte inferior da seção **Trabalho**. Este exemplo mostra o JSON para uma tarefa simples.

**nota**  
Substitua *JOB\$1QUEUE\$1ARN* pela fila de trabalhos do MediaConvert, *IAM\$1ROLE\$1ARN* pelo nome do recurso da Amazon (ARN) do perfil do IAM, *OUTPUT\$1BUCKET\$1NAME* pelo nome do bucket de destino, por exemplo, “s3://OUTPUT\$1BUCKET\$1NAME/”, e *INPUT\$1BUCKET\$1AND\$1FILENAME* pelo bucket de entrada e nome do arquivo, por exemplo, “s3://INPUT\$1BUCKET/FILE\$1NAME”.

```
const params = {
  Queue: "JOB_QUEUE_ARN", //JOB_QUEUE_ARN
  UserMetadata: {
    Customer: "Amazon",
  },
  Role: "IAM_ROLE_ARN", //IAM_ROLE_ARN
  Settings: {
    OutputGroups: [
      {
        Name: "File Group",
        OutputGroupSettings: {
          Type: "FILE_GROUP_SETTINGS",
          FileGroupSettings: {
            Destination: "OUTPUT_BUCKET_NAME", //OUTPUT_BUCKET_NAME, e.g., "s3://BUCKET_NAME/"
          },
        },
        Outputs: [
          {
            VideoDescription: {
              ScalingBehavior: "DEFAULT",
              TimecodeInsertion: "DISABLED",
              AntiAlias: "ENABLED",
              Sharpness: 50,
              CodecSettings: {
                Codec: "H_264",
                H264Settings: {
                  InterlaceMode: "PROGRESSIVE",
                  NumberReferenceFrames: 3,
                  Syntax: "DEFAULT",
                  Softness: 0,
                  GopClosedCadence: 1,
                  GopSize: 90,
                  Slices: 1,
                  GopBReference: "DISABLED",
                  SlowPal: "DISABLED",
                  SpatialAdaptiveQuantization: "ENABLED",
                  TemporalAdaptiveQuantization: "ENABLED",
                  FlickerAdaptiveQuantization: "DISABLED",
                  EntropyEncoding: "CABAC",
                  Bitrate: 5000000,
                  FramerateControl: "SPECIFIED",
                  RateControlMode: "CBR",
                  CodecProfile: "MAIN",
                  Telecine: "NONE",
                  MinIInterval: 0,
                  AdaptiveQuantization: "HIGH",
                  CodecLevel: "AUTO",
                  FieldEncoding: "PAFF",
                  SceneChangeDetect: "ENABLED",
                  QualityTuningLevel: "SINGLE_PASS",
                  FramerateConversionAlgorithm: "DUPLICATE_DROP",
                  UnregisteredSeiTimecode: "DISABLED",
                  GopSizeUnits: "FRAMES",
                  ParControl: "SPECIFIED",
                  NumberBFramesBetweenReferenceFrames: 2,
                  RepeatPps: "DISABLED",
                  FramerateNumerator: 30,
                  FramerateDenominator: 1,
                  ParNumerator: 1,
                  ParDenominator: 1,
                },
              },
              AfdSignaling: "NONE",
              DropFrameTimecode: "ENABLED",
              RespondToAfd: "NONE",
              ColorMetadata: "INSERT",
            },
            AudioDescriptions: [
              {
                AudioTypeControl: "FOLLOW_INPUT",
                CodecSettings: {
                  Codec: "AAC",
                  AacSettings: {
                    AudioDescriptionBroadcasterMix: "NORMAL",
                    RateControlMode: "CBR",
                    CodecProfile: "LC",
                    CodingMode: "CODING_MODE_2_0",
                    RawFormat: "NONE",
                    SampleRate: 48000,
                    Specification: "MPEG4",
                    Bitrate: 64000,
                  },
                },
                LanguageCodeControl: "FOLLOW_INPUT",
                AudioSourceName: "Audio Selector 1",
              },
            ],
            ContainerSettings: {
              Container: "MP4",
              Mp4Settings: {
                CslgAtom: "INCLUDE",
                FreeSpaceBox: "EXCLUDE",
                MoovPlacement: "PROGRESSIVE_DOWNLOAD",
              },
            },
            NameModifier: "_1",
          },
        ],
      },
    ],
    AdAvailOffset: 0,
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
        FileInput: "INPUT_BUCKET_AND_FILENAME", //INPUT_BUCKET_AND_FILENAME, e.g., "s3://BUCKET_NAME/FILE_NAME"
      },
    ],
    TimecodeConfig: {
      Source: "EMBEDDED",
    },
  },
};
```

## Criar uma tarefa de transcodificação
<a name="emc-examples-jobs-create"></a>

Depois de criar o JSON de parâmetros de tarefa, chame o método `run` assíncrono para invocar um objeto de serviço de cliente do `MediaConvert`, passando os parâmetros. O ID da tarefa criado é retornado no da resposta `data`.

```
const run = async () => {
  try {
    const data = await emcClient.send(new CreateJobCommand(params));
    console.log("Job created!", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node emc_createjob.js 
```

Esse código de exemplo completo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_createjob.js).

## Cancelar uma tarefa de transcodificação
<a name="emc-examples-jobs-cancel"></a>

Crie um módulo do Node.js com o nome de arquivo `emc_canceljob.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo o download dos clientes e pacotes necessários. Crie o JSON que inclua o ID da tarefa a ser cancelada. Depois, chame o método `CancelJobCommand` criando uma promessa para invocar um objeto de serviço de cliente do `MediaConvert`, passando os parâmetros. Lide com a resposta no retorno de chamada da promessa.

**nota**  
Substitua *JOB\$1ID* pelo ID da tarefa a ser cancelada.

```
// Import required AWS-SDK clients and commands for Node.js
import { CancelJobCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = { Id: "JOB_ID" }; //JOB_ID

const run = async () => {
  try {
    const data = await emcClient.send(new CancelJobCommand(params));
    console.log(`Job  ${params.Id} is canceled`);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node ec2_canceljob.js 
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_canceljob.js).

## Como lista tarefas de transcodificação recentes
<a name="emc-examples-jobs-listing"></a>

Crie um módulo do Node.js com o nome de arquivo `emc_listjobs.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie o JSON de parâmetros, incluindo valores para especificar se você deseja classificar a lista em ordem `ASCENDING` ou `DESCENDING`, o Nome do recurso da Amazon (ARN) da fila de tarefas a ser verificada e o status das tarefas a serem incluídas. Depois, chame o método `ListJobsCommand` criando uma promessa para invocar um objeto de serviço de cliente do `MediaConvert`, passando os parâmetros. 

**nota**  
Substitua *QUEUE\$1ARN* pelo Nome do recurso da Amazon (ARN) da fila de tarefas a ser verificada e *STATUS* pelo status da fila.

```
// Import required AWS-SDK clients and commands for Node.js
import { ListJobsCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = {
  MaxResults: 10,
  Order: "ASCENDING",
  Queue: "QUEUE_ARN",
  Status: "SUBMITTED", // e.g., "SUBMITTED"
};

const run = async () => {
  try {
    const data = await emcClient.send(new ListJobsCommand(params));
    console.log("Success. Jobs: ", data.Jobs);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node emc_listjobs.js 
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_listjobs.js).

# Uso de modelos de trabalho no MediaConvert
<a name="emc-examples-templates"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como criar modelos de tarefa do AWS Elemental MediaConvert.
+ Como usar um modelo de tarefa para criar uma tarefa de transcodificação.
+ Como listar todos os modelos de tarefa.
+ Como excluir modelos de tarefa.

## O cenário
<a name="emc-examples-templates-scenario"></a>

O JSON necessário para criar um trabalho de transcodificação no MediaConvert é detalhado, contendo um grande número de configurações. Simplifique muito a criação de tarefas salvando as configurações em boas condições em um modelo de tarefa que você possa usar para criar tarefas subsequentes. Neste exemplo, você usa um módulo Node.js a fim de chamar o MediaConvert para criar, usar e gerenciar modelos de trabalho. O código usa o SDK para JavaScript para fazer isso usando estes métodos da classe de cliente do MediaConvert:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/)

## Tarefas de pré-requisito
<a name="emc-example-templates-prerequisites"></a>

Para configurar e executar este exemplo, primeiro conclua estas tarefas:
+ Configure o ambiente do projeto para executar estes exemplos do Node TypeScript e instale os módulos do AWS SDK para JavaScript e de terceiros necessários. Siga as instruções no [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no *Guia de referência de ferramentas e SDKs da AWS*.
+ Crie um perfil do IAM que dê ao MediaConvert acesso aos arquivos de entrada e aos buckets do Amazon S3 onde os arquivos de saída são armazenados. Para obter detalhes, consulte [Configurar permissões do IAM](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) no *Guia do usuário do AWS Elemental MediaConvert*.

**Importante**  
Esses exemplos usam ECMAScript6 (ES6). Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).  
No entanto, se você preferir usar a sintaxe CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Criar um modelo de trabalho
<a name="emc-examples-templates-create"></a>

Crie um módulo do Node.js com o nome de arquivo `emc_create_jobtemplate.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Especifique o JSON de parâmetros para a criação do modelo. Use a maioria dos parâmetros JSON de uma tarefa anterior bem-sucedida para especificar os valores `Settings` no modelo. Este exemplo usa as configurações de tarefa de [Criar e gerenciar tarefas de transcodificação no MediaConvert](emc-examples-jobs.md).

Chame o método `CreateJobTemplateCommand` criando uma promessa para invocar um objeto de serviço de cliente do `MediaConvert`, passando os parâmetros.

**nota**  
Substitua *JOB\$1QUEUE\$1ARN* pelo Nome do recurso da Amazon (ARN) da fila de trabalhos a ser verificada e *BUCKET\$1NAME* pelo nome do bucket do Amazon S3 de destino. Por exemplo, "s3://BUCKET\$1NAME/". 

```
// Import required AWS-SDK clients and commands for Node.js
import { CreateJobTemplateCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  Category: "YouTube Jobs",
  Description: "Final production transcode",
  Name: "DemoTemplate",
  Queue: "JOB_QUEUE_ARN", //JOB_QUEUE_ARN
  Settings: {
    OutputGroups: [
      {
        Name: "File Group",
        OutputGroupSettings: {
          Type: "FILE_GROUP_SETTINGS",
          FileGroupSettings: {
            Destination: "BUCKET_NAME", // BUCKET_NAME e.g., "s3://BUCKET_NAME/"
          },
        },
        Outputs: [
          {
            VideoDescription: {
              ScalingBehavior: "DEFAULT",
              TimecodeInsertion: "DISABLED",
              AntiAlias: "ENABLED",
              Sharpness: 50,
              CodecSettings: {
                Codec: "H_264",
                H264Settings: {
                  InterlaceMode: "PROGRESSIVE",
                  NumberReferenceFrames: 3,
                  Syntax: "DEFAULT",
                  Softness: 0,
                  GopClosedCadence: 1,
                  GopSize: 90,
                  Slices: 1,
                  GopBReference: "DISABLED",
                  SlowPal: "DISABLED",
                  SpatialAdaptiveQuantization: "ENABLED",
                  TemporalAdaptiveQuantization: "ENABLED",
                  FlickerAdaptiveQuantization: "DISABLED",
                  EntropyEncoding: "CABAC",
                  Bitrate: 5000000,
                  FramerateControl: "SPECIFIED",
                  RateControlMode: "CBR",
                  CodecProfile: "MAIN",
                  Telecine: "NONE",
                  MinIInterval: 0,
                  AdaptiveQuantization: "HIGH",
                  CodecLevel: "AUTO",
                  FieldEncoding: "PAFF",
                  SceneChangeDetect: "ENABLED",
                  QualityTuningLevel: "SINGLE_PASS",
                  FramerateConversionAlgorithm: "DUPLICATE_DROP",
                  UnregisteredSeiTimecode: "DISABLED",
                  GopSizeUnits: "FRAMES",
                  ParControl: "SPECIFIED",
                  NumberBFramesBetweenReferenceFrames: 2,
                  RepeatPps: "DISABLED",
                  FramerateNumerator: 30,
                  FramerateDenominator: 1,
                  ParNumerator: 1,
                  ParDenominator: 1,
                },
              },
              AfdSignaling: "NONE",
              DropFrameTimecode: "ENABLED",
              RespondToAfd: "NONE",
              ColorMetadata: "INSERT",
            },
            AudioDescriptions: [
              {
                AudioTypeControl: "FOLLOW_INPUT",
                CodecSettings: {
                  Codec: "AAC",
                  AacSettings: {
                    AudioDescriptionBroadcasterMix: "NORMAL",
                    RateControlMode: "CBR",
                    CodecProfile: "LC",
                    CodingMode: "CODING_MODE_2_0",
                    RawFormat: "NONE",
                    SampleRate: 48000,
                    Specification: "MPEG4",
                    Bitrate: 64000,
                  },
                },
                LanguageCodeControl: "FOLLOW_INPUT",
                AudioSourceName: "Audio Selector 1",
              },
            ],
            ContainerSettings: {
              Container: "MP4",
              Mp4Settings: {
                CslgAtom: "INCLUDE",
                FreeSpaceBox: "EXCLUDE",
                MoovPlacement: "PROGRESSIVE_DOWNLOAD",
              },
            },
            NameModifier: "_1",
          },
        ],
      },
    ],
    AdAvailOffset: 0,
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
      },
    ],
    TimecodeConfig: {
      Source: "EMBEDDED",
    },
  },
};

const run = async () => {
  try {
    // Create a promise on a MediaConvert object
    const data = await emcClient.send(new CreateJobTemplateCommand(params));
    console.log("Success!", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node emc_create_jobtemplate.js 
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_create_jobtemplate.js).

## Criar um trabalho de transcodificação com base em um modelo de trabalho
<a name="emc-examples-templates-createjob"></a>

Crie um módulo do Node.js com o nome de arquivo `emc_template_createjob.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie o JSON de parâmetros da criação de tarefas, inclusive o nome do modelo de tarefa a ser usado, e o `Settings` para usar os específicos da tarefa que você está criando. Depois, chame o método `CreateJobsCommand` criando uma promessa para invocar um objeto de serviço de cliente do `MediaConvert`, passando os parâmetros. 

**nota**  
Substitua *JOB\$1QUEUE\$1ARN* pelo nome do recurso da Amazon (ARN) da fila de trabalhos a ser verificada, *KEY\$1PAIR\$1NAME*, *TEMPLATE\$1NAME* e *ROLE\$1ARN* pelo nome do recurso da Amazon (ARN) da função e * INPUT\$1BUCKET\$1AND\$1FILENAME* pelo bucket de entrada e nome do arquivo. por exemplo, “s3://BUCKET\$1NAME/FILE\$1NAME”.

```
// Import required AWS-SDK clients and commands for Node.js
import { CreateJobCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  Queue: "QUEUE_ARN", //QUEUE_ARN
  JobTemplate: "TEMPLATE_NAME", //TEMPLATE_NAME
  Role: "ROLE_ARN", //ROLE_ARN
  Settings: {
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
        FileInput: "INPUT_BUCKET_AND_FILENAME", //INPUT_BUCKET_AND_FILENAME, e.g., "s3://BUCKET_NAME/FILE_NAME"
      },
    ],
  },
};

const run = async () => {
  try {
    const data = await emcClient.send(new CreateJobCommand(params));
    console.log("Success! ", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node emc_template_createjob.js 
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Como listar os modelos de trabalho
<a name="emc-examples-templates-listing"></a>

Crie um módulo do Node.js com o nome de arquivo `emc_listtemplates.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar os parâmetros de solicitação para o método `listTemplates` da classe de cliente `MediaConvert`. Inclua valores para determinar quais modelos listar (`NAME`, `CREATION DATE`, `SYSTEM`), quantas listar e a ordem de classificação. Para chamar o método `ListTemplatesCommand`, crie uma promessa para invocar um objeto de serviço de cliente do MediaConvert, passando os parâmetros. 

```
// Import required AWS-SDK clients and commands for Node.js
import { ListJobTemplatesCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  ListBy: "NAME",
  MaxResults: 10,
  Order: "ASCENDING",
};

const run = async () => {
  try {
    const data = await emcClient.send(new ListJobTemplatesCommand(params));
    console.log("Success ", data.JobTemplates);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node emc_listtemplates.js 
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Excluir um modelo de trabalho
<a name="emc-examples-templates-delete"></a>

Crie um módulo do Node.js com o nome de arquivo `emc_deletetemplate.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar o nome do modelo de tarefa que você deseja excluir como parâmetro do método `DeleteJobTemplateCommand` da classe de cliente `MediaConvert`. Para chamar o método `DeleteJobTemplateCommand`, crie uma promessa para invocar um objeto de serviço de cliente do MediaConvert, passando os parâmetros. 

```
// Import required AWS-SDK clients and commands for Node.js
import { DeleteJobTemplateCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = { Name: "test" }; //TEMPLATE_NAME

const run = async () => {
  try {
    const data = await emcClient.send(new DeleteJobTemplateCommand(params));
    console.log(
      "Success, template deleted! Request ID:",
      data.$metadata.requestId,
    );
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node emc_deletetemplate.js 
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_deletetemplate.js).

# AWS LambdaExemplos da
<a name="lambda-examples"></a>

AWS Lambda é um serviço de computação com tecnologia sem servidor que permite executar código sem provisionar ou gerenciar servidores, criar uma lógica de escalonamento de cluster com reconhecimento de workload, manter integrações de eventos ou gerenciar runtimes. 

A API JavaScript do AWS Lambda é exposta por meio da classe de cliente [LambdaService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lambda/).

Veja a seguir uma lista de exemplos que demonstram como criar e usar funções do Lambda com o AWS SDK para JavaScript v3:
+ [Invocar o Lambda com o API Gateway](api-gateway-invoking-lambda-example.md)
+ [Criação de eventos agendados para executar AWS Lambda funções](scheduled-events-invoking-lambda-example.md)

# Exemplos do Amazon Lex
<a name="lex-examples"></a>

O Amazon Lex é um serviço da AWS para a criação de interfaces de conversa em aplicativos que usam voz e texto. 

A API JavaScript para Amazon Lex é exposta por meio da classe de cliente [Serviço de runtime do Lex](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lex-runtime-service/).
+ [Criar um chatbot do Amazon Lex](lex-bot-example.md)

# Exemplos do Amazon Polly
<a name="polly-examples"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Faça upload do áudio gravado usando o Amazon Polly para o Amazon S3

## O cenário
<a name="polly-example-synthesize-to-s3-scenario"></a>

Neste exemplo, uma série de módulos Node.js é usada para carregar automaticamente o áudio gravado usando o Amazon Polly para o Amazon S3 usando esses métodos da classe de cliente Amazon S3:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/)

## Tarefas de pré-requisito
<a name="polly-example-synthesize-to-s3-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure um ambiente de projeto para executar JavaScript exemplos do Node seguindo as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/s3/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.
+ Crie uma política de funções de usuário do Amazon Cognito AWS Identity and Access Management (IAM) não autenticadaSynthesizeSpeech : permissões e um pool de identidade do Amazon Cognito com a função do IAM anexada a ela. A seção [Crie os AWS recursos usando o CloudFormation](#polly-example-synthesize-to-s3-create-resources) abaixo descreve como criar esses recursos.

**nota**  
Este exemplo usa o Amazon Cognito, mas se você não estiver usando o Amazon Cognito, AWS seu usuário deverá seguir a política de permissões do IAM  

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": [
        "mobileanalytics:PutEvents",
        "cognito-sync:*"
      ],
      "Resource": "*",
      "Effect": "Allow"
    },
    {
      "Action": "polly:SynthesizeSpeech",
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}
```

## Crie os AWS recursos usando o CloudFormation
<a name="polly-example-synthesize-to-s3-create-resources"></a>

CloudFormation permite que você crie e provisione implantações de AWS infraestrutura de forma previsível e repetida. Para obter mais informações sobre CloudFormation, consulte o [Guia AWS CloudFormation do usuário](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para criar a CloudFormation pilha:

1. Instale e configure as instruções a AWS CLI seguir no [Guia AWS CLI do usuário](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Crie um arquivo chamado `setup.yaml` no diretório raiz da pasta do seu projeto e copie o conteúdo [aqui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/polly/general-examples/src/setup.yaml) para dentro dele. 
**nota**  
O CloudFormation modelo foi gerado usando o AWS CDK disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/javascript_example_code_polly_aws_service/). Para obter mais informações sobre o AWS CDK, consulte o [Guia do AWS Cloud Development Kit (AWS CDK) desenvolvedor](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Execute o comando a seguir na linha de comando, *STACK\$1NAME* substituindo-o por um nome exclusivo para a pilha.
**Importante**  
O nome da pilha deve ser exclusivo dentro de uma AWS região e AWS conta. Você pode especificar até 128 caracteres. São permitidos números e hifens.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obter mais informações sobre os parâmetros do comando `create-stack`, consulte o [Guia de referência de comandos da AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) e o [Guia do usuário do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Navegue até o console CloudFormation de gerenciamento, escolha **Pilhas**, escolha o nome da pilha e escolha a guia **Recursos** para ver uma lista dos recursos criados.  
![\[CloudFormation recursos\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/cfn_polly.png)

## Faça upload do áudio gravado usando o Amazon Polly para o Amazon S3
<a name="polly-example-synthesize-to-s3-example"></a>

Crie um módulo do Node.js com o nome de arquivo `polly_synthesize_to_s3.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. No código, insira o *REGION* e *BUCKET\$1NAME* o. Para acessar o Amazon Polly, crie um objeto de serviço de cliente do `Polly`. *"IDENTITY\$1POOL\$1ID"*Substitua pela `IdentityPoolId` da **página de amostra** do pool de identidade do Amazon Cognito que você criou para este exemplo. Isso também é passado para cada objeto do cliente.

Chame o método `StartSpeechSynthesisCommand` do objeto de serviço de cliente do Amazon Polly, sintetize a mensagem de voz e carregue-a para o bucket do Amazon S3. 

```
import { StartSpeechSynthesisTaskCommand } from "@aws-sdk/client-polly";
import { pollyClient } from "./libs/pollyClient.js";

// Create the parameters
const params = {
  OutputFormat: "mp3",
  OutputS3BucketName: "videoanalyzerbucket",
  Text: "Hello David, How are you?",
  TextType: "text",
  VoiceId: "Joanna",
  SampleRate: "22050",
};

const run = async () => {
  try {
    await pollyClient.send(new StartSpeechSynthesisTaskCommand(params));
    console.log(`Success, audio file added to ${params.OutputS3BucketName}`);
  } catch (err) {
    console.log("Error putting object", err);
  }
};
run();
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/polly/general-examples/src/polly_synthesize_to_s3.js).

# Exemplos do Amazon Redshift
<a name="redshift-examples"></a>

O Amazon Redshift é um serviço de data warehouse em escala de petabytes totalmente gerenciado na nuvem. Um data warehouse do Amazon Redshift é um conjunto de recursos de computação chamados *nós*, que são organizados em um grupo chamado *cluster*. Cada cluster executa um mecanismo do Amazon Redshift e contém um ou mais bancos de dados.

![\[Relação entre ambientes JavaScript, o SDK e o Amazon Redshift\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/code-samples-redshift.png)


A API JavaScript para Amazon Redshift é exposta por meio da classe de cliente do [Amazon Redshift](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/Redshift/).

**Topics**
+ [Exemplos do Amazon Redshift](redshift-examples-section.md)

# Exemplos do Amazon Redshift
<a name="redshift-examples-section"></a>

Neste exemplo, uma série de módulos Node.js é usada para criar, modificar, descrever os parâmetros e, em seguida, excluir clusters do Amazon Redshift usando os seguintes métodos da classe de cliente do `Redshift`:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/)

Para obter mais informações sobre usuários do Amazon Redshift, consulte o [Guia de conceitos básicos do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html).

## Tarefas de pré-requisito
<a name="s3-example-configuring-buckets-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar estes exemplos do Node TypeScript e instale os módulos do AWS SDK para JavaScript e de terceiros necessários. Siga as instruções no[ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no *Guia de referência de ferramentas e SDKs da AWS*.

**Importante**  
Esses exemplos demonstram como importar/exportar objetos e comandos do serviço de cliente usando o ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Criação de um cluster do Amazon Redshift
<a name="redshift-create-cluster"></a>

Este exemplo demonstra como criar um cluster do Amazon Redshift usando o AWS SDK para JavaScript. Para obter mais informações, consulte [CreateCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster).

**Importante**  
*O cluster que você está prestes a criar está ativo (e não está sendo executado em uma sandbox). Você será cobrado pelas taxas de uso padrão do Amazon Redshift para o cluster até que o exclua. Se você excluir o cluster na mesma sessão em que o criou, o valor total cobrado será mínimo. * 

Crie um diretório `libs` e um módulo Node.js com o nome de arquivo`redshiftClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Redshift. Substitua *REGION* pela sua região da AWS.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crie um módulo do Node.js com o nome de arquivo `redshift-create-cluster.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto de parâmetros, especificando o tipo de nó a ser provisionado, e as credenciais principais de login para a instância do banco de dados criada automaticamente no cluster e, finalmente, o tipo de cluster.

**nota**  
Substitua *CLUSTER\$1NAME* pelo nome do cluster. Para *NODE\$1TYPE*, especifique o tipo de nó a ser provisionado, como 'dc2.large', por exemplo. *MASTER\$1USERNAME* e *MASTER\$1USER\$1PASSWORD* são as credenciais de login do usuário principal da sua instância de banco de dados no cluster. Para *CLUSTER\$1TYPE*, insira o tipo de cluster. Se você especificar `single-node`, não precisará do parâmetro `NumberOfNodes`. Todos os parâmetros restantes são opcionais. 

```
// Import required AWS SDK clients and commands for Node.js
import { CreateClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME", // Required
  NodeType: "NODE_TYPE", //Required
  MasterUsername: "MASTER_USER_NAME", // Required - must be lowercase
  MasterUserPassword: "MASTER_USER_PASSWORD", // Required - must contain at least one uppercase letter, and one number
  ClusterType: "CLUSTER_TYPE", // Required
  IAMRoleARN: "IAM_ROLE_ARN", // Optional - the ARN of an IAM role with permissions your cluster needs to access other AWS services on your behalf, such as Amazon S3.
  ClusterSubnetGroupName: "CLUSTER_SUBNET_GROUPNAME", //Optional - the name of a cluster subnet group to be associated with this cluster. Defaults to 'default' if not specified.
  DBName: "DATABASE_NAME", // Optional - defaults to 'dev' if not specified
  Port: "PORT_NUMBER", // Optional - defaults to '5439' if not specified
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new CreateClusterCommand(params));
    console.log(
      `Cluster ${data.Cluster.ClusterIdentifier} successfully created`,
    );
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node redshift-create-cluster.js  
```

Este código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-create-cluster.js).

## Modificação de um cluster do Amazon Redshift
<a name="redshift-modify-cluster"></a>

Este exemplo mostra como modificar a senha do usuário principal de um cluster do Amazon Redshift usando o AWS SDK para JavaScript. Para obter mais informações sobre quais outras configurações você pode modificar, consulte [ModifyCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_ModifyCluster.html).

Crie um diretório `libs` e um módulo Node.js com o nome de arquivo`redshiftClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Redshift. Substitua *REGION* pela sua região da AWS.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crie um módulo do Node.js com o nome de arquivo `redshift-modify-cluster.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Especifique a Região AWS, o nome do cluster que você deseja modificar e a nova senha do usuário principal.

**nota**  
Substitua *CLUSTER\$1NAME* pelo nome do cluster e *MASTER\$1USER\$1PASSWORD* pela nova senha do usuário principal. 

```
// Import required AWS SDK clients and commands for Node.js
import { ModifyClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

// Set the parameters
const params = {
  ClusterIdentifier: "CLUSTER_NAME",
  MasterUserPassword: "NEW_MASTER_USER_PASSWORD",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new ModifyClusterCommand(params));
    console.log("Success was modified.", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node redshift-modify-cluster.js 
```

Este código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-modify-cluster.js).

## Visualização de detalhes de um cluster do Amazon Redshift
<a name="redshift-describe-cluster"></a>

Este exemplo mostra como visualizar os detalhes de um cluster do Amazon Redshift usando o AWS SDK para JavaScript. Para obter mais informações sobre opcionais, consulte [DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html).

Crie um diretório `libs` e um módulo Node.js com o nome de arquivo`redshiftClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Redshift. Substitua *REGION* pela sua região da AWS.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crie um módulo do Node.js com o nome de arquivo `redshift-describe-clusters.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Especifique a Região AWS, o nome do cluster que você deseja modificar e a nova senha do usuário principal.

**nota**  
Substitua *CLUSTER\$1NAME* pelo nome do cluster. 

```
// Import required AWS SDK clients and commands for Node.js
import { DescribeClustersCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new DescribeClustersCommand(params));
    console.log("Success", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node redshift-describe-clusters.js 
```

Este código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-describe-clusters.js).

## Excluir um cluster do Amazon Redshift
<a name="redshift-delete-cluster"></a>

Este exemplo mostra como visualizar os detalhes de um cluster do Amazon Redshift usando o AWS SDK para JavaScript. Para obter mais informações sobre quais outras configurações você pode modificar, consulte [DeleteCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DeleteCluster.html).

Crie um diretório `libs` e um módulo Node.js com o nome de arquivo`redshiftClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Redshift. Substitua *REGION* pela sua região da AWS.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Esse código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crie um módulo Node.js com o nome de arquivo `redshift-delete-clusters.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Especifique a Região AWS, o nome do cluster que você deseja modificar e a nova senha do usuário principal. Em seguida, especifique se você deseja salvar um snapshot final do cluster antes de excluí-lo e, em caso afirmativo, o ID do snapshot.

**nota**  
Substitua *CLUSTER\$1NAME* pelo nome do cluster. Para o *SkipFinalClusterSnapshot*, especifique se deseja criar um snapshot final do cluster antes de excluí-lo. Se você especificar 'false', especifique o id do snapshot final do cluster em *CLUSTER\$1SNAPSHOT\$1ID*. Você pode obter esse ID clicando no link da coluna **Snapshots** do cluster no painel **Clusters** e rolando para baixo até o painel **Snapshots**. Observe que o radical `rs:` não faz parte do ID do snapshot.

```
// Import required AWS SDK clients and commands for Node.js
import { DeleteClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME",
  SkipFinalClusterSnapshot: false,
  FinalClusterSnapshotIdentifier: "CLUSTER_SNAPSHOT_ID",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new DeleteClusterCommand(params));
    console.log("Success, cluster deleted. ", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node redshift-delete-cluster.js  
```

Este código de exemplo pode ser encontrado [aqui no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-delete-cluster.js).

# Exemplos do Amazon Simple Email Service
<a name="ses-examples"></a>

O Amazon Simple Email Service (Amazon SES) é um serviço de envio de e-mails baseado na nuvem criado para ajudar profissionais de marketing digital e desenvolvedores de aplicativos a enviar e-mails de marketing, notificações e mensagens transacionais. Ele é um serviço confiável e econômico para empresas de todos os tamanhos que usam e-mail para manter contato com seus clientes.

![\[Relação entre JavaScript ambientes, o SDK e o Amazon SES\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)


A JavaScript API do Amazon SES é exposta por meio da classe `SES` cliente. Para obter mais informações sobre como usar a classe de cliente do Amazon SES, consulte [Classe: SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) na Referência da API.

**Topics**
+ [Gerenciamento de identidades do Amazon SES](ses-examples-managing-identities.md)
+ [Trabalhar com modelos de e-mail no Amazon SES](ses-examples-creating-template.md)
+ [Envio de e-mail usando o Amazon SES](ses-examples-sending-email.md)

# Gerenciamento de identidades do Amazon SES
<a name="ses-examples-managing-identities"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como verificar endereços de e-mail e domínios usados com o Amazon SES.
+ Como atribuir uma política AWS Identity and Access Management (IAM) às suas identidades do Amazon SES.
+ Como listar todas as identidades do Amazon SES para sua AWS conta.
+ Como excluir identidades usadas com o Amazon SES.

Uma *identidade* do Amazon SES é um endereço de e-mail ou domínio que o Amazon SES usa para enviar e-mails. O Amazon SES requer que você verifique suas identidades de e-mail, confirmando que você é o proprietário delas e impedindo que outras pessoas as utilizem.

Para obter detalhes sobre como verificar endereços de e-mail e domínios no Amazon SES, consulte [Verificar endereços de e-mail e domínios no Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) no Guia do desenvolvedor do Amazon Simple Email Service. Para obter informações sobre autorização de envio no Amazon SES, consulte [Visão geral da autorização de envio do Amazon SES](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).

## O cenário
<a name="ses-examples-verifying-identities-scenario"></a>

Neste exemplo, você usa uma série de módulos do Node.js para verificar e gerenciar identidades do Amazon SES. Os módulos Node.js usam o SDK JavaScript para verificar endereços de e-mail e domínios, usando esses métodos da classe `SES` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/)

## Tarefas de pré-requisito
<a name="ses-examples-verifying-identities-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Listar suas identidades
<a name="ses-examples-listing-identities"></a>

Neste exemplo, use um módulo do Node.js para listar endereços de e-mail e domínios para usar com o Amazon SES.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_listidentities.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar o `IdentityType` e outros parâmetros para o método `ListIdentitiesCommand` da classe de cliente `SES`. Para chamar o método `ListIdentitiesCommand`, invoque um objeto de serviço do Amazon SES passando o objeto dos parâmetros. 

 O `data` retornado contém um array de identidades de domínio, conforme especificado pelo parâmetro `IdentityType`.

**nota**  
*IdentityType*Substitua pelo tipo de identidade, que pode ser EmailAddress "" ou “Domínio”.

```
import { ListIdentitiesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createListIdentitiesCommand = () =>
  new ListIdentitiesCommand({ IdentityType: "EmailAddress", MaxItems: 10 });

const run = async () => {
  const listIdentitiesCommand = createListIdentitiesCommand();

  try {
    return await sesClient.send(listIdentitiesCommand);
  } catch (err) {
    console.log("Failed to list identities.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node ses_listidentities.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).

## Verificar a identidade de um endereço de e-mail
<a name="ses-examples-verifying-email"></a>

Neste exemplo, use um módulo do Node.js para verificar remetentes de e-mail para usar com o Amazon SES.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_verifyemailidentity.js`. Configure o SDK conforme mostrado anteriormente, incluindo o download dos clientes e pacotes necessários. 

Crie um objeto para passar o parâmetro `EmailAddress` para o método `VerifyEmailIdentityCommand` da classe de cliente `SES`. Para chamar o método `VerifyEmailIdentityCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros. 

**nota**  
*EMAIL\$1ADDRESS*Substitua pelo endereço de e-mail, como name@example.com.

```
// Import required AWS SDK clients and commands for Node.js
import { VerifyEmailIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const EMAIL_ADDRESS = "name@example.com";

const createVerifyEmailIdentityCommand = (emailAddress) => {
  return new VerifyEmailIdentityCommand({ EmailAddress: emailAddress });
};

const run = async () => {
  const verifyEmailIdentityCommand =
    createVerifyEmailIdentityCommand(EMAIL_ADDRESS);
  try {
    return await sesClient.send(verifyEmailIdentityCommand);
  } catch (err) {
    console.log("Failed to verify email identity.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O domínio é adicionado ao Amazon SES a ser verificado.

```
node ses_verifyemailidentity.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).

## Verificar uma identidade de domínio
<a name="ses-examples-verifying-domains"></a>

Neste exemplo, use um módulo do Node.js para verificar domínios de e-mail a serem usados com o Amazon SES.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_verifydomainidentity.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar o parâmetro `Domain` para o método `VerifyDomainIdentityCommand` da classe de cliente `SES`. Para chamar o método `VerifyDomainIdentityCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando o objeto dos parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*DOMAIN\$1NAME*Substitua pelo nome do domínio.

```
import { VerifyDomainIdentityCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * You must have access to the domain's DNS settings to complete the
 * domain verification process.
 */
const DOMAIN_NAME = postfix(getUniqueName("Domain"), ".example.com");

const createVerifyDomainIdentityCommand = () => {
  return new VerifyDomainIdentityCommand({ Domain: DOMAIN_NAME });
};

const run = async () => {
  const VerifyDomainIdentityCommand = createVerifyDomainIdentityCommand();

  try {
    return await sesClient.send(VerifyDomainIdentityCommand);
  } catch (err) {
    console.log("Failed to verify domain.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O domínio é adicionado ao Amazon SES a ser verificado.

```
node ses_verifydomainidentity.js  
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).

## Excluir identidades
<a name="ses-examples-deleting-identities"></a>

Neste exemplo, use um módulo do Node.js para excluir endereços de e-mail ou domínios usados com o Amazon SES.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_deleteidentity.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar o parâmetro `Identity` para o método `DeleteIdentityCommand` da classe de cliente `SES`. Para chamar o método `DeleteIdentityCommand`, crie uma `request` para invocar um objeto de serviço de cliente do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*IDENTITY\$1EMAIL*Substitua pelo e-mail da identidade a ser excluída.

```
import { DeleteIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const IDENTITY_EMAIL = "fake@example.com";

const createDeleteIdentityCommand = (identityName) => {
  return new DeleteIdentityCommand({
    Identity: identityName,
  });
};

const run = async () => {
  const deleteIdentityCommand = createDeleteIdentityCommand(IDENTITY_EMAIL);

  try {
    return await sesClient.send(deleteIdentityCommand);
  } catch (err) {
    console.log("Failed to delete identity.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node ses_deleteidentity.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).

# Trabalhar com modelos de e-mail no Amazon SES
<a name="ses-examples-creating-template"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como obter uma lista de todos os modelos de e-mail.
+ Como recuperar e atualizar os modelos de e-mail.
+ Como criar e excluir modelos de e-mail.

O Amazon SES permite que você envie mensagens de e-mail personalizadas usando modelos de e-mail. Para obter detalhes sobre como criar e usar modelos de e-mail no Amazon SES, consulte [Envio de e-mail personalizado usando a API do Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) no Guia do desenvolvedor do Amazon Simple Email Service.

## O cenário
<a name="ses-examples-creating-template-scenario"></a>

Neste exemplo, você usa uma série de módulos do Node.js para trabalhar com modelos de e-mail. Os módulos Node.js usam o SDK JavaScript para criar e usar modelos de e-mail usando esses métodos da classe `SES` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/)

## Tarefas de pré-requisito
<a name="ses-examples-creating-template-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Listar seus modelos de e-mail
<a name="ses-examples-listing-templates"></a>

Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_listtemplates.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar os parâmetros para o método `ListTemplatesCommand` da classe de cliente `SES`. Para chamar o método `ListTemplatesCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

```
import { ListTemplatesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createListTemplatesCommand = (maxItems) =>
  new ListTemplatesCommand({ MaxItems: maxItems });

const run = async () => {
  const listTemplatesCommand = createListTemplatesCommand(10);

  try {
    return await sesClient.send(listTemplatesCommand);
  } catch (err) {
    console.log("Failed to list templates.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna a lista de modelos.

```
node ses_listtemplates.js  
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js).

## Obter um modelo de e-mail
<a name="ses-examples-get-template"></a>

Neste exemplo, use um módulo do Node.js para obter um modelo de e-mail a ser usado com o Amazon SES.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_gettemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar o parâmetro `TemplateName` para o método `GetTemplateCommand` da classe de cliente `SES`. Para chamar o método `GetTemplateCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*TEMPLATE\$1NAME*Substitua pelo nome do modelo a ser devolvido.

```
import { GetTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");

const createGetTemplateCommand = (templateName) =>
  new GetTemplateCommand({ TemplateName: templateName });

const run = async () => {
  const getTemplateCommand = createGetTemplateCommand(TEMPLATE_NAME);

  try {
    return await sesClient.send(getTemplateCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna os detalhes do modelo.

```
node ses_gettemplate.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).

## Criar um modelo de e-mail
<a name="ses-examples-create-template"></a>

Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_createtemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar os parâmetros do método `CreateTemplateCommand` da classe de cliente `SES`, incluindo `TemplateName`, `HtmlPart`, `SubjectPart` e `TextPart`. Para chamar o método `CreateTemplateCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*TEMPLATE\$1NAME*Substitua por um nome para o novo modelo, *HtmlPart* pelo conteúdo do e-mail marcado em HTML e *SubjectPart* pelo assunto do e-mail.

```
import { CreateTemplateCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";

const TEMPLATE_NAME = getUniqueName("TestTemplateName");

const createCreateTemplateCommand = () => {
  return new CreateTemplateCommand({
    /**
     * The template feature in Amazon SES is based on the Handlebars template system.
     */
    Template: {
      /**
       * The name of an existing template in Amazon SES.
       */
      TemplateName: TEMPLATE_NAME,
      HtmlPart: `
        <h1>Hello, {{contact.firstName}}!</h1>
        <p>
        Did you know Amazon has a mascot named Peccy?
        </p>
      `,
      SubjectPart: "Amazon Tip",
    },
  });
};

const run = async () => {
  const createTemplateCommand = createCreateTemplateCommand();

  try {
    return await sesClient.send(createTemplateCommand);
  } catch (err) {
    console.log("Failed to create template.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O modelo é adicionado ao Amazon SES.

```
node ses_createtemplate.js  
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).

## Atualização de um modelo de e-mail
<a name="ses-examples-update-template"></a>

Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_updatetemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar os valores do parâmetro `Template` que você deseja atualizar no modelo, com o parâmetro `TemplateName` passado para o método `UpdateTemplateCommand` da classe de cliente `SES`. Para chamar o método `UpdateTemplateCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*TEMPLATE\$1NAME*Substitua pelo nome do modelo e *HTML\$1PART* pelo conteúdo do e-mail marcado em HTML.

```
import { UpdateTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");
const HTML_PART = "<h1>Hello, World!</h1>";

const createUpdateTemplateCommand = () => {
  return new UpdateTemplateCommand({
    Template: {
      TemplateName: TEMPLATE_NAME,
      HtmlPart: HTML_PART,
      SubjectPart: "Example",
      TextPart: "Updated template text.",
    },
  });
};

const run = async () => {
  const updateTemplateCommand = createUpdateTemplateCommand();

  try {
    return await sesClient.send(updateTemplateCommand);
  } catch (err) {
    console.log("Failed to update template.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna os detalhes do modelo.

```
node ses_updatetemplate.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).

## Exclusão de um modelo de e-mail
<a name="ses-examples-delete-template"></a>

Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_deletetemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar o parâmetro `TemplateName` obrigatório para o método `DeleteTemplateCommand` da classe de cliente `SES`. Para chamar o método `DeleteTemplateCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*TEMPLATE\$1NAME*Substitua pelo nome do modelo a ser excluído.

```
import { DeleteTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");

const createDeleteTemplateCommand = (templateName) =>
  new DeleteTemplateCommand({ TemplateName: templateName });

const run = async () => {
  const deleteTemplateCommand = createDeleteTemplateCommand(TEMPLATE_NAME);

  try {
    return await sesClient.send(deleteTemplateCommand);
  } catch (err) {
    console.log("Failed to delete template.", err);
    return err;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna os detalhes do modelo.

```
node ses_deletetemplate.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).

# Envio de e-mail usando o Amazon SES
<a name="ses-examples-sending-email"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Envie uma e-mail de texto ou HTML.
+ Envie e-mails usando um modelo de e-mail.
+ Envie e-mails em massa usando um modelo de e-mail.

A API do Amazon SES fornece duas maneiras diferentes para você enviar um e-mail, dependendo de quanto controle você deseja ter sobre a composição da mensagem de e-mail: formatada e bruta. Para obter detalhes, consulte [Enviar e-mail formatado usando a API do Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) e [Enviar e-mail bruto usando a API do Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).

## O cenário
<a name="ses-examples-sending-email-scenario"></a>

Neste exemplo, você usa uma série de módulos do Node.js para enviar e-mails de várias maneiras. Os módulos Node.js usam o SDK JavaScript para criar e usar modelos de e-mail usando esses métodos da classe `SES` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/)

## Tarefas de pré-requisito
<a name="ses-examples-sending-emails-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Requisitos de envio de mensagens de e-mail
<a name="ses-examples-sending-msail-reqs"></a>

O Amazon SES compõe uma mensagem de e-mail e imediatamente a coloca na fila para envio. Para enviar e-mail usando o método `SendEmailCommand`, sua mensagem deve atender aos seguintes requisitos:
+ Você deve enviar a mensagem a partir de um domínio ou endereço de e-mail verificado. Se você tentar enviar um e-mail usando um domínio ou endereço não verificados, a operação resultará no erro `"Email address not verified"`.
+ Se sua conta ainda estiver na sandbox do Amazon SES, você só poderá enviar para endereços ou domínios verificados ou para endereços de e-mail associados simulador de caixa postal do Amazon SES. Para obter mais informações, consulte [Verificar endereços de e-mail e domínios](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) no Guia do desenvolvedor do Amazon Simple Email Service.
+ O tamanho total da mensagem, incluindo anexos, deve ser menor que 10 MB.
+ A mensagem deve incluir pelo menos um endereço de e-mail de destinatário. O endereço do destinatário pode ser um endereço Para:, um endereço CC: ou um endereço CCO:. Se o endereço de e-mail do destinatário for inválido (ou seja, não estiver no formato `UserName@[SubDomain.]Domain.TopLevelDomain`), a mensagem inteira será rejeitada, mesmo se a mensagem contiver outros destinatários válidos.
+ A mensagem não pode incluir mais de 50 destinatários nos campos Para:, CC: e CCO:. Se você precisar enviar uma mensagem de e-mail para um público maior, pode dividir a lista de destinatários em grupos de 50 ou menos e chamar o método `sendEmail` várias vezes para enviar a mensagem para cada grupo.

## Enviar um e-mail
<a name="ses-examples-sendmail"></a>

Neste exemplo, use um módulo do Node.js para enviar e-mail com o Amazon SES. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_sendemail.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para transmitir os valores de parâmetro que definem o e-mail a ser enviado, incluindo endereços do remetente e do destinatário, assunto e corpo do e-mail em texto sem formatação e formato HTML, para o método `SendEmailCommand` da classe de cliente `SES`. Para chamar o método `SendEmailCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*toAddress*Substitua pelo endereço para o qual enviar o e-mail e *fromAddress* pelo endereço de e-mail do qual enviar o e-mail.

```
import { SendEmailCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createSendEmailCommand = (toAddress, fromAddress) => {
  return new SendEmailCommand({
    Destination: {
      /* required */
      CcAddresses: [
        /* more items */
      ],
      ToAddresses: [
        toAddress,
        /* more To-email addresses */
      ],
    },
    Message: {
      /* required */
      Body: {
        /* required */
        Html: {
          Charset: "UTF-8",
          Data: "HTML_FORMAT_BODY",
        },
        Text: {
          Charset: "UTF-8",
          Data: "TEXT_FORMAT_BODY",
        },
      },
      Subject: {
        Charset: "UTF-8",
        Data: "EMAIL_SUBJECT",
      },
    },
    Source: fromAddress,
    ReplyToAddresses: [
      /* more items */
    ],
  });
};

const run = async () => {
  const sendEmailCommand = createSendEmailCommand(
    "recipient@example.com",
    "sender@example.com",
  );

  try {
    return await sesClient.send(sendEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O e-mail é colocado na fila para ser enviado pelo Amazon SES.

```
node ses_sendemail.js 
```

Esse código de exemplo pode ser [encontrado aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js). 

## Enviar um e-mail usando um modelo
<a name="ses-examples-sendtemplatedemail"></a>

Neste exemplo, use um módulo do Node.js para enviar e-mail com o Amazon SES. Crie um módulo do Node.js com o nome de arquivo `ses_sendtemplatedemail.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para transmitir os valores de parâmetro que definem o e-mail a ser enviado, incluindo endereços do remetente e do destinatário, assunto, corpo do e-mail em texto sem formatação e formato HTML, para o método `SendTemplatedEmailCommand` da classe de cliente `SES`. Para chamar o método `SendTemplatedEmailCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*REGION*Substitua pela sua AWS região, *USER* pelo nome e endereço de e-mail para o qual enviar o e-mail, *VERIFIED\$1EMAIL* pelo endereço de e-mail do qual enviar o e-mail e *TEMPLATE\$1NAME* pelo nome do modelo.

```
import { SendTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * Replace this with the name of an existing template.
 */
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");

/**
 * Replace these with existing verified emails.
 */
const VERIFIED_EMAIL = postfix(getUniqueName("Bilbo"), "@example.com");

const USER = { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL };

/**
 *
 * @param { { emailAddress: string, firstName: string } } user
 * @param { string } templateName - The name of an existing template in Amazon SES.
 * @returns { SendTemplatedEmailCommand }
 */
const createReminderEmailCommand = (user, templateName) => {
  return new SendTemplatedEmailCommand({
    /**
     * Here's an example of how a template would be replaced with user data:
     * Template: <h1>Hello {{contact.firstName}},</h1><p>Don't forget about the party gifts!</p>
     * Destination: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destination: { ToAddresses: [user.emailAddress] },
    TemplateData: JSON.stringify({ contact: { firstName: user.firstName } }),
    Source: VERIFIED_EMAIL,
    Template: templateName,
  });
};

const run = async () => {
  const sendReminderEmailCommand = createReminderEmailCommand(
    USER,
    TEMPLATE_NAME,
  );
  try {
    return await sesClient.send(sendReminderEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O e-mail é colocado na fila para ser enviado pelo Amazon SES.

```
node ses_sendtemplatedemail.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js).

## Enviar um e-mail em massa usando um modelo
<a name="ses-examples-sendbulktemplatedemail"></a>

Neste exemplo, use um módulo do Node.js para enviar e-mail com o Amazon SES. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crie um módulo do Node.js com o nome de arquivo `ses_sendbulktemplatedemail.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. 

Crie um objeto para transmitir os valores de parâmetro que definem o e-mail a ser enviado, incluindo endereços do remetente e do destinatário, assunto e corpo do e-mail em texto sem formatação e formato HTML, para o método `SendBulkTemplatedEmailCommand` da classe de cliente `SES`. Para chamar o método `SendBulkTemplatedEmailCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros. 

**nota**  
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).

**nota**  
*USERS*Substitua pelos nomes e endereços de e-mail para os quais enviar o e-mail, *VERIFIED\$1EMAIL\$11* pelo endereço de e-mail do qual enviar o e-mail e *TEMPLATE\$1NAME* pelo nome do modelo.

```
import { SendBulkTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * Replace this with the name of an existing template.
 */
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");

/**
 * Replace these with existing verified emails.
 */
const VERIFIED_EMAIL_1 = postfix(getUniqueName("Bilbo"), "@example.com");
const VERIFIED_EMAIL_2 = postfix(getUniqueName("Frodo"), "@example.com");

const USERS = [
  { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL_1 },
  { firstName: "Frodo", emailAddress: VERIFIED_EMAIL_2 },
];

/**
 *
 * @param { { emailAddress: string, firstName: string }[] } users
 * @param { string } templateName the name of an existing template in SES
 * @returns { SendBulkTemplatedEmailCommand }
 */
const createBulkReminderEmailCommand = (users, templateName) => {
  return new SendBulkTemplatedEmailCommand({
    /**
     * Each 'Destination' uses a corresponding set of replacement data. We can map each user
     * to a 'Destination' and provide user specific replacement data to create personalized emails.
     *
     * Here's an example of how a template would be replaced with user data:
     * Template: <h1>Hello {{name}},</h1><p>Don't forget about the party gifts!</p>
     * Destination 1: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     * Destination 2: <h1>Hello Frodo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destinations: users.map((user) => ({
      Destination: { ToAddresses: [user.emailAddress] },
      ReplacementTemplateData: JSON.stringify({ name: user.firstName }),
    })),
    DefaultTemplateData: JSON.stringify({ name: "Shireling" }),
    Source: VERIFIED_EMAIL_1,
    Template: templateName,
  });
};

const run = async () => {
  const sendBulkTemplateEmailCommand = createBulkReminderEmailCommand(
    USERS,
    TEMPLATE_NAME,
  );
  try {
    return await sesClient.send(sendBulkTemplateEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando. O e-mail é colocado na fila para ser enviado pelo Amazon SES.

```
node ses_sendbulktemplatedemail.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js). 

# Exemplos do Amazon Simple Notification Service
<a name="sns-examples"></a>

O Amazon Simple Notification Service (Amazon SNS) é um serviço web que coordena e gerencia a entrega ou o envio de mensagens para endpoints ou clientes assinantes. 

No Amazon SNS, há dois tipos de clientes – os publicadores e os assinantes – também chamados de produtores e consumidores. 

![\[Relação entre JavaScript ambientes, o SDK e o Amazon SNS\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/code-samples-sns.png)


Os editores se comunicam de maneira assíncrona com os inscritos produzindo e enviando uma mensagem para um tópico, que é um canal de comunicação e um ponto de acesso lógico. Os assinantes (servidores web, endereços de e-mail, filas do Amazon SQS, AWS Lambda funções) consomem ou recebem a mensagem ou notificação por meio de um dos protocolos suportados (Amazon SQS, HTTP/S, e-mail, SMS AWS Lambda) quando estão inscritos no tópico. 

A JavaScript API do Amazon SNS é exposta por meio da [Classe:](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SNS/) SNS. 

**Topics**
+ [Gerenciamento de tópicos no Amazon SNS](sns-examples-managing-topics.md)
+ [Publicação de mensagens no Amazon SNS](sns-examples-publishing-messages.md)
+ [Gerenciamento de assinaturas no Amazon SNS](sns-examples-subscribing-unsubscribing-topics.md)
+ [Enviar mensagens SMS com o Amazon SNS](sns-examples-sending-sms.md)

# Gerenciamento de tópicos no Amazon SNS
<a name="sns-examples-managing-topics"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como criar tópicos no Amazon SNS para os quais você pode publicar notificações.
+ Como excluir tópicos criados no Amazon SNS.
+ Como obter uma lista de tópicos disponíveis.
+ Como obter e definir atributos de tópicos.

## O cenário
<a name="sns-examples-managing-topics-scenario"></a>

Neste exemplo, você usa uma série de módulos do Node.js para criar, listar e excluir tópicos do Amazon SNS e para lidar com atributos de tópicos. Os módulos Node.js usam o SDK JavaScript para gerenciar tópicos usando esses métodos da classe `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/)

## Tarefas de pré-requisito
<a name="sns-examples-managing-topics-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Criar um tópico
<a name="sns-examples-managing-topics-createtopic"></a>

Neste exemplo, use um módulo do Node.js para criar um tópico do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `create-topic.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto para passar o `Name` para o novo tópico para o método `CreateTopicCommand` da classe de cliente `SNS`. Para chamar o método `CreateTopicCommand`, crie uma função assíncrona que invoca um objeto de serviço do Amazon SNS, passando o objeto dos parâmetros. O `data` retornado contém o ARN do tópico.

**nota**  
*TOPIC\$1NAME*Substitua pelo nome do tópico.

```
import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicName - The name of the topic to create.
 */
export const createTopic = async (topicName = "TOPIC_NAME") => {
  const response = await snsClient.send(
    new CreateTopicCommand({ Name: topicName }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node create-topic.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/create-topic.js).

## Listar os tópicos do
<a name="sns-examples-managing-topics-listtopics"></a>

Neste exemplo, use um módulo do Node.js para listar todos os tópicos do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `list-topics.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto vazio para passar para o método `ListTopicsCommand` da classe de cliente `SNS`. Para chamar o método `ListTopicsCommand`, crie uma função assíncrona que invoca um objeto de serviço do Amazon SNS, passando o objeto dos parâmetros. O `data` retornado contém uma matriz do seu tópico Amazon Resource Names (ARNs).

```
import { ListTopicsCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const listTopics = async () => {
  const response = await snsClient.send(new ListTopicsCommand({}));
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '936bc5ad-83ca-53c2-b0b7-9891167b909e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Topics: [ { TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic' } ]
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node list-topics.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-topics.js).

## Exclusão de um tópico
<a name="sns-examples-managing-topics-deletetopic"></a>

Neste exemplo, use um módulo do Node.js para excluir um tópico do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `delete-topic.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto contendo o `TopicArn` do tópico para excluir e passar para o método `DeleteTopicCommand` da classe de cliente `SNS`. Para chamar o método `DeleteTopicCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1ARN*Substitua pelo nome de recurso da Amazon (ARN) do tópico que você está excluindo.

```
import { DeleteTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic to delete.
 */
export const deleteTopic = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new DeleteTopicCommand({ TopicArn: topicArn }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'a10e2886-5a8f-5114-af36-75bd39498332',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node delete-topic.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/delete-topic.js).

## Obter atributos do tópico
<a name="sns-examples-managing-topicsgettopicattributes"></a>

Neste exemplo, use um módulo do Node.js para recuperar atributos de um tópico do Amazon SNS.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `get-topic-attributes.js`. Configure o SDK como mostrado anteriormente.

Crie um objeto contendo o `TopicArn` de um tópico para excluir e passar para o método `GetTopicAttributesCommand` da classe de cliente `SNS`. Para chamar o método `GetTopicAttributesCommand`, invoque um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1ARN*Substitua pelo ARN do tópico.

```
import { GetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic to retrieve attributes for.
 */
export const getTopicAttributes = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new GetTopicAttributesCommand({
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '36b6a24e-5473-5d4e-ac32-ff72d9a73d94',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Attributes: {
  //     Policy: '{...}',
  //     Owner: 'xxxxxxxxxxxx',
  //     SubscriptionsPending: '1',
  //     TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic',
  //     TracingConfig: 'PassThrough',
  //     EffectiveDeliveryPolicy: '{"http":{"defaultHealthyRetryPolicy":{"minDelayTarget":20,"maxDelayTarget":20,"numRetries":3,"numMaxDelayRetries":0,"numNoDelayRetries":0,"numMinDelayRetries":0,"backoffFunction":"linear"},"disableSubscriptionOverrides":false,"defaultRequestPolicy":{"headerContentType":"text/plain; charset=UTF-8"}}}',
  //     SubscriptionsConfirmed: '0',
  //     DisplayName: '',
  //     SubscriptionsDeleted: '1'
  //   }
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node get-topic-attributes.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-topic-attributes.js).

## Definir atributos do tópico
<a name="sns-examples-managing-topicssttopicattributes"></a>

Neste exemplo, use um módulo do Node.js para definir os atributos mutáveis de um tópico do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `set-topic-attributes.js`. Configure o SDK como mostrado anteriormente.

Crie um objeto contendo os parâmetros para a atualização do atributo, incluindo o `TopicArn` do tópico cujos atributos você deseja definir, o nome do atributo a ser definido e o novo valor desse atributo. É possível definir apenas os atributos `Policy`, `DisplayName` e `DeliveryPolicy`. Passe os parâmetros para o método `SetTopicAttributesCommand` da classe de cliente `SNS`. Para chamar o método `SetTopicAttributesCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*ATTRIBUTE\$1NAME*Substitua pelo nome do atributo que você está definindo, *TOPIC\$1ARN* pelo Amazon Resource Name (ARN) do tópico cujos atributos você deseja definir e *NEW\$1ATTRIBUTE\$1VALUE* pelo novo valor desse atributo.

```
import { SetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const setTopicAttributes = async (
  topicArn = "TOPIC_ARN",
  attributeName = "DisplayName",
  attributeValue = "Test Topic",
) => {
  const response = await snsClient.send(
    new SetTopicAttributesCommand({
      AttributeName: attributeName,
      AttributeValue: attributeValue,
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'd1b08d0e-e9a4-54c3-b8b1-d03238d2b935',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node set-topic-attributes.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-topic-attributes.js).

# Publicação de mensagens no Amazon SNS
<a name="sns-examples-publishing-messages"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como publicar mensagens em um tópico do Amazon SNS.

## O cenário
<a name="sns-examples-publishing-messages-scenario"></a>

Neste exemplo, você usa uma série de módulos do Node.js para publicar mensagens do Amazon SNS nos endpoints do tópico, e-mails ou números de telefone. Os módulos Node.js usam o SDK JavaScript para enviar mensagens usando esse método da classe `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Tarefas de pré-requisito
<a name="sns-examples-publishing-messages-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Publicar uma mensagem em um tópico do SNS
<a name="sns-examples-publishing-text-messages"></a>

Neste exemplo, use um módulo do Node.js para publicar uma mensagem em um tópico do Amazon SNS.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crie um módulo do Node.js com o nome de arquivo `publish-topic.js`. Configure o SDK como mostrado anteriormente.

Crie um objeto contendo os parâmetros para publicar uma mensagem, incluindo o texto da mensagem e o Amazon Resource Name (ARN) da Amazon. SNStopic Para obter detalhes sobre os atributos de SMS disponíveis, consulte [Definir SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html#setSMSAttributes-property).

Passe os parâmetros para o método `PublishCommand` da classe de cliente `SNS`. Crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*MESSAGE\$1TEXT*Substitua pelo texto da mensagem e *TOPIC\$1ARN* pelo ARN do tópico do SNS.

```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string | Record<string, any>} message - The message to send. Can be a plain string or an object
 *                                                 if you are using the `json` `MessageStructure`.
 * @param {string} topicArn - The ARN of the topic to which you would like to publish.
 */
export const publish = async (
  message = "Hello from SNS!",
  topicArn = "TOPIC_ARN",
) => {
  const response = await snsClient.send(
    new PublishCommand({
      Message: message,
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'e7f77526-e295-5325-9ee4-281a43ad1f05',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node publish-topic.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-topic.js).

# Gerenciamento de assinaturas no Amazon SNS
<a name="sns-examples-subscribing-unsubscribing-topics"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como listar todas as assinaturas para um tópico do Amazon SNS.
+ Como inscrever um endereço de e-mail, um endpoint de aplicativo ou uma função do AWS Lambda em um tópico do Amazon SNS.
+ Como cancelar a assinatura dos tópicos do Amazon SNS.

## O cenário
<a name="sns-examples-subscribing-unsubscribing-topics-scenario"></a>

Neste exemplo, você usa uma série de módulos do Node.js para publicar mensagens de notificação em tópicos do Amazon SNS. Os módulos Node.js usam o SDK JavaScript para gerenciar tópicos usando esses métodos da classe `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/)

## Tarefas de pré-requisito
<a name="sns-examples-subscribing-unsubscribing-topics-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Listar assinaturas em um tópico
<a name="sns-examples-list-subscriptions-email"></a>

Neste exemplo, use um módulo do Node.js para listar todas as assinaturas para um tópico do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crie um módulo do Node.js com o nome de arquivo `list-subscriptions-by-topic.js`. Configure o SDK como mostrado anteriormente.

Crie um objeto contendo o parâmetro `TopicArn` para o tópico cujas assinaturas você deseja listar. Passe os parâmetros para o método `ListSubscriptionsByTopicCommand` da classe de cliente `SNS`. Para chamar o método `ListSubscriptionsByTopicCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1ARN*Substitua pelo Amazon Resource Name (ARN) do tópico cujas assinaturas você deseja listar.

```
import { ListSubscriptionsByTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic for which you wish to list subscriptions.
 */
export const listSubscriptionsByTopic = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new ListSubscriptionsByTopicCommand({ TopicArn: topicArn }),
  );

  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '0934fedf-0c4b-572e-9ed2-a3e38fadb0c8',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Subscriptions: [
  //     {
  //       SubscriptionArn: 'PendingConfirmation',
  //       Owner: '901487484989',
  //       Protocol: 'email',
  //       Endpoint: 'corepyle@amazon.com',
  //       TopicArn: 'arn:aws:sns:us-east-1:901487484989:mytopic'
  //     }
  //   ]
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node list-subscriptions-by-topic.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-subscriptions-by-topic.js).

## Inscrever um endereço de e-mail em um tópico
<a name="sns-examples-subscribing-email"></a>

Neste exemplo, use um módulo do Node.js para inscrever um endereço de e-mail de forma que ele receba mensagens de e-mail SMTP de um tópico do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `subscribe-email.js`. Configure o SDK como mostrado anteriormente.

Crie um objeto que contém o parâmetro `Protocol` para especificar o protocolo `email`, o `TopicArn` do tópico a ser assinado e um endereço de e-mail como `Endpoint` da mensagem. Passe os parâmetros para o método `SubscribeCommand` da classe de cliente `SNS`. Você pode usar o método `subscribe` para assinar vários endpoints diferentes para um tópico do Amazon SNS, dependendo dos valores usados para os parâmetros passados, como outros exemplos neste tópico mostrarão.

Para chamar o método `SubscribeCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1ARN*Substitua pelo Amazon Resource Name (ARN) do tópico e pelo endereço *EMAIL\$1ADDRESS* de e-mail para assinar.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
 * @param {string} emailAddress - The email address that is subscribed to the topic.
 */
export const subscribeEmail = async (
  topicArn = "TOPIC_ARN",
  emailAddress = "usern@me.com",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "email",
      TopicArn: topicArn,
      Endpoint: emailAddress,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node subscribe-email.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-email.js).

### Confirmação de assinaturas
<a name="sns-confirm-subscription-email"></a>

Neste exemplo, use um módulo do Node.js para verificar a intenção do proprietário de um endpoint de receber mensagens validando o token enviado para o endpoint por uma ação de assinatura anterior.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `confirm-subscription.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Defina os parâmetros, incluindo `TOPIC_ARN` e `TOKEN`, e defina um valor de `TRUE` ou `FALSE` para `AuthenticateOnUnsubscribe`.

O token é de curta duração enviado ao proprietário de um endpoint durante uma ação de `SUBSCRIBE` anterior. Por exemplo, para um endpoint de e-mail, o `TOKEN` está no URL do e-mail de confirmação da assinatura enviado ao proprietário do e-mail. Por exemplo, `abc123` é o token no seguinte URL.

![\[Amazon Web Services Simple Notification Service subscription confirmation page.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/token.png)


Para chamar o método `ConfirmSubscriptionCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1ARN*Substitua pelo Amazon Resource Name (ARN) do tópico, *TOKEN* pelo valor do token da URL enviada ao proprietário do endpoint em uma `Subscribe` ação anterior e defina*AuthenticateOnUnsubscribe*. com um valor de ou. `TRUE` `FALSE`

```
import { ConfirmSubscriptionCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} token - This token is sent the subscriber. Only subscribers
 *                         that are not AWS services (HTTP/S, email) need to be confirmed.
 * @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
 */
export const confirmSubscription = async (
  token = "TOKEN",
  topicArn = "TOPIC_ARN",
) => {
  const response = await snsClient.send(
    // A subscription only needs to be confirmed if the endpoint type is
    // HTTP/S, email, or in another AWS account.
    new ConfirmSubscriptionCommand({
      Token: token,
      TopicArn: topicArn,
      // If this is true, the subscriber cannot unsubscribe while unauthenticated.
      AuthenticateOnUnsubscribe: "false",
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '4bb5bce9-805a-5517-8333-e1d2cface90b',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node confirm-subscription.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/confirm-subscription.js).

## Inscrever um endpoint de aplicativo em um tópico
<a name="sns-examples-subscribing-apps"></a>

Neste exemplo, use um módulo do Node.js para inscrever um endpoint de aplicativo móvel para receber notificações de um tópico do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `subscribe-app.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos módulos e pacotes necessários.

Crie um objeto contendo o parâmetro `Protocol` para especificar o protocolo `application`, o `TopicArn` para o tópico no qual será feita a assinatura e o nome do recurso da Amazon (ARN) do endpoint de um aplicativo móvel para o parâmetro `Endpoint`. Passe os parâmetros para o método `SubscribeCommand` da classe de cliente `SNS`.

Para chamar o método `SubscribeCommand`, crie uma função assíncrona que invoca um objeto de serviço do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1ARN*Substitua pelo Amazon Resource Name (ARN) do tópico e *MOBILE\$1ENDPOINT\$1ARN* pelo endpoint em que você está assinando o tópico.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
 * @param {string} endpoint - The Endpoint ARN of an application. This endpoint is created
 *                            when an application registers for notifications.
 */
export const subscribeApp = async (
  topicArn = "TOPIC_ARN",
  endpoint = "ENDPOINT",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "application",
      TopicArn: topicArn,
      Endpoint: endpoint,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node subscribe-app.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-app.js).

## Inscrever uma função do Lambda em um tópico
<a name="sns-examples-subscribing-lambda"></a>

Neste exemplo, use um módulo Node.js para assinar uma AWS Lambda função para que ela receba notificações de um tópico do Amazon SNS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `subscribe-lambda.js`. Configure o SDK como mostrado anteriormente.

Crie um objeto contendo o `Protocol` parâmetro, especificando o `lambda` protocolo, o `TopicArn` tópico a ser assinado e o Amazon Resource Name (ARN) de AWS Lambda uma função como `Endpoint` parâmetro. Passe os parâmetros para o método `SubscribeCommand` da classe de cliente `SNS`.

Para chamar o método `SubscribeCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1ARN*Substitua pelo Amazon Resource Name (ARN) do tópico e *LAMBDA\$1FUNCTION\$1ARN* pelo Amazon Resource Name (ARN) da função Lambda.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
 * @param {string} endpoint - The Endpoint ARN of and AWS Lambda function.
 */
export const subscribeLambda = async (
  topicArn = "TOPIC_ARN",
  endpoint = "ENDPOINT",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "lambda",
      TopicArn: topicArn,
      Endpoint: endpoint,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node subscribe-lambda.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-lambda.js).

## Cancelar a inscrição em um tópico
<a name="sns-examples-unsubscribing"></a>

Neste exemplo, use um módulo do Node.js para cancelar a assinatura de um tópico do Amazon SNS.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `unsubscribe.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.

Crie um objeto que contém o parâmetro `SubscriptionArn`, especificando o nome do recurso da Amazon (ARN) da assinatura para cancelar a assinatura. Passe os parâmetros para o método `UnsubscribeCommand` da classe de cliente `SNS`.

Para chamar o método `UnsubscribeCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TOPIC\$1SUBSCRIPTION\$1ARN*Substitua pelo Amazon Resource Name (ARN) da assinatura para cancelar a assinatura.

```
import { UnsubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} subscriptionArn - The ARN of the subscription to cancel.
 */
const unsubscribe = async (
  subscriptionArn = "arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
) => {
  const response = await snsClient.send(
    new UnsubscribeCommand({
      SubscriptionArn: subscriptionArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '0178259a-9204-507c-b620-78a7570a44c6',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node unsubscribe.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/unsubscribe.js).

# Enviar mensagens SMS com o Amazon SNS
<a name="sns-examples-sending-sms"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Este exemplo de código Node.js mostra:**
+ Como obter e definir as preferências de mensagens SMS para Amazon SNS.
+ Como verificar um número de telefone para definir se ele não permite o recebimento de mensagens SMS.
+ Como obter uma lista de números de telefone que cancelaram o recebimento de mensagens SMS.
+ Como enviar uma mensagem SMS.

## O cenário
<a name="sns-examples-sending-sms-scenario"></a>

Você pode usar o Amazon SNS para enviar mensagens de texto ou mensagens SMS para dispositivos habilitados para SMS. Você pode enviar uma mensagem diretamente para um número de telefone, ou enviar uma mensagem para vários números de telefone de uma só vez inscrevendo esses números em um tópico e enviando sua mensagem para o tópico.

Neste exemplo, você usa uma série de módulos do Node.js para publicar mensagens de texto SMS do Amazon SNS em dispositivos habilitados para SMS. Os módulos Node.js usam o SDK JavaScript para publicar mensagens SMS usando esses métodos da classe `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Tarefas de pré-requisito
<a name="sns-examples-sending-sms-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Obter atributos do SMS
<a name="sending-sms-getattributes"></a>

Use o Amazon SNS para especificar as preferências para o uso de mensagens SMS, por exemplo, como suas entregas serão otimizadas (para fins de custo ou confiabilidade), o limite de gastos mensais, como as entregas de mensagens serão registradas e a assinatura em relatórios diários de uso de SMS. Essas preferências são recuperadas e definidas como atributos de SMS para Amazon SNS.

Neste exemplo, use um módulo do Node.js para obter os atributos de SMS atuais no Amazon SNS.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crie um módulo do Node.js com o nome de arquivo `get-sms-attributes.js`.

Configure o SDK conforme mostrado anteriormente, incluindo o download dos clientes e pacotes necessários. Crie um objeto contendo os parâmetros para obter atributos de SMS, incluindo os nomes dos atributos individuais a serem obtidos. Para obter detalhes sobre os atributos de SMS disponíveis, consulte [Definir SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) na Referência da API do Amazon Simple Notification Service.

Esse exemplo usa o atributo `DefaultSMSType`, que controla se serão enviadas mensagens SMS como `Promotional`, o que otimiza a entrega de mensagens para gerar custos mais baixos, ou como `Transactional`, que otimiza a entrega de mensagens para gerar a mais alta confiabilidade. Passe os parâmetros para o método `SetTopicAttributesCommand` da classe de cliente `SNS`. Para chamar o método `SetSMSAttributesCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*ATTRIBUTE\$1NAME*Substitua pelo nome do atributo.

```
import { GetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const getSmsAttributes = async () => {
  const response = await snsClient.send(
    // If you have not modified the account-level mobile settings of SNS,
    // the DefaultSMSType is undefined. For this example, it was set to
    // Transactional.
    new GetSMSAttributesCommand({ attributes: ["DefaultSMSType"] }),
  );

  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '67ad8386-4169-58f1-bdb9-debd281d48d5',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   attributes: { DefaultSMSType: 'Transactional' }
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node get-sms-attributes.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-sms-attributes.js).

## Definir atributos do SMS
<a name="sending-sms-setattributes"></a>

Neste exemplo, use um módulo do Node.js para obter os atributos de SMS atuais no Amazon SNS.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crie um módulo do Node.js com o nome de arquivo `set-sms-attribute-type.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto contendo os parâmetros para definir atributos de SMS, incluindo os nomes dos atributos individuais a serem definidos e os valores para cada um. Para obter detalhes sobre os atributos de SMS disponíveis, consulte [Definir SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) na Referência da API do Amazon Simple Notification Service.

Este exemplo define o atributo `DefaultSMSType` para `Transactional`, que otimiza a entrega de mensagens para gerar a mais alta confiabilidade. Passe os parâmetros para o método `SetTopicAttributesCommand` da classe de cliente `SNS`. Para chamar o método `SetSMSAttributesCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

```
import { SetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {"Transactional" | "Promotional"} defaultSmsType
 */
export const setSmsType = async (defaultSmsType = "Transactional") => {
  const response = await snsClient.send(
    new SetSMSAttributesCommand({
      attributes: {
        // Promotional – (Default) Noncritical messages, such as marketing messages.
        // Transactional – Critical messages that support customer transactions,
        // such as one-time passcodes for multi-factor authentication.
        DefaultSMSType: defaultSmsType,
      },
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '1885b977-2d7e-535e-8214-e44be727e265',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node set-sms-attribute-type.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-sms-attribute-type.js).

## Verificar se um número de telefone cancelou o recebimento
<a name="sending-sms-checkifphonenumberisoptedout"></a>

Neste exemplo, use um módulo do Node.js para verificar um número de telefone e determinar se ele cancelou o recebimento de mensagens SMS. 

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `check-if-phone-number-is-opted-out.js`. Configure o SDK como mostrado anteriormente. Crie um objeto contendo o número de telefone a ser verificado como parâmetro.

Este exemplo define o parâmetro `PhoneNumber` para especificar o número de telefone a ser verificado. Passe o objeto para o método `CheckIfPhoneNumberIsOptedOutCommand` da classe de cliente `SNS`. Para chamar o método `CheckIfPhoneNumberIsOptedOutCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  

*PHONE\$1NUMBER*Substitua pelo número de telefone.

```
import { CheckIfPhoneNumberIsOptedOutCommand } from "@aws-sdk/client-sns";

import { snsClient } from "../libs/snsClient.js";

export const checkIfPhoneNumberIsOptedOut = async (
  phoneNumber = "5555555555",
) => {
  const command = new CheckIfPhoneNumberIsOptedOutCommand({
    phoneNumber,
  });

  const response = await snsClient.send(command);
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '3341c28a-cdc8-5b39-a3ee-9fb0ee125732',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   isOptedOut: false
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node check-if-phone-number-is-opted-out.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/check-if-phone-number-is-opted-out.js).

## Listar números de telefone que cancelaram o recebimento
<a name="sending-sms-listphonenumbersoptedout"></a>

Neste exemplo, use um módulo do Node.js para obter uma lista de telefones que cancelaram o recebimento de mensagens SMS.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `list-phone-numbers-opted-out.js`. Configure o SDK como mostrado anteriormente. Crie um objeto vazio como parâmetro.

Passe o objeto para o método `ListPhoneNumbersOptedOutCommand` da classe de cliente `SNS`. Para chamar o método `ListPhoneNumbersOptedOutCommand`, crie uma função assíncrona que invoca um objeto de serviço de cliente do Amazon SNS, passando o objeto dos parâmetros. 

```
import { ListPhoneNumbersOptedOutCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const listPhoneNumbersOptedOut = async () => {
  const response = await snsClient.send(
    new ListPhoneNumbersOptedOutCommand({}),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '44ff72fd-1037-5042-ad96-2fc16601df42',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   phoneNumbers: ['+15555550100']
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node list-phone-numbers-opted-out.js 
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-phone-numbers-opted-out.js).

## Publicar uma mensagem SMS
<a name="sending-sms-publishsms"></a>

Neste exemplo, use um módulo do Node.js para enviar uma mensagem SMS a um número de telefone.

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `snsClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SNS. *REGION*Substitua pela sua AWS região.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crie um módulo do Node.js com o nome de arquivo `publish-sms.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto contendo os parâmetros `Message` e `PhoneNumber`.

Ao enviar uma mensagem SMS, especifique o número de telefone usando o formato E.164. E.164 é um padrão para a estrutura de número de telefone usada para telecomunicações internacionais. Números de telefone que seguem esse formato podem ter um máximo de 15 dígitos, e eles são prefixados com o caractere de mais (\$1) e o código do país. Por exemplo, um número de telefone dos EUA no formato E.164 apareceria como \$11001. XXX5550100 

Este exemplo define o parâmetro `PhoneNumber` para especificar o número de telefone ao qual a mensagem deve ser enviada. Passe o objeto para o método `PublishCommand` da classe de cliente `SNS`. Para chamar o método `PublishCommand`, crie uma função assíncrona que invoca um objeto de serviço do Amazon SNS, passando o objeto dos parâmetros. 

**nota**  
*TEXT\$1MESSAGE*Substitua pela mensagem de texto e *PHONE\$1NUMBER* pelo número de telefone.

```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string | Record<string, any>} message - The message to send. Can be a plain string or an object
 *                                                 if you are using the `json` `MessageStructure`.
 * @param {*} phoneNumber - The phone number to send the message to.
 */
export const publish = async (
  message = "Hello from SNS!",
  phoneNumber = "+15555555555",
) => {
  const response = await snsClient.send(
    new PublishCommand({
      Message: message,
      // One of PhoneNumber, TopicArn, or TargetArn must be specified.
      PhoneNumber: phoneNumber,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '7410094f-efc7-5f52-af03-54737569ab77',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node publish-sms.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-sms.js).

# Exemplos do Amazon Transcribe
<a name="Transcribe-examples"></a>

O Amazon Transcribe facilita para os desenvolvedores adicionarem o recurso de conversão de fala em texto aos seus aplicativos. 

![\[Relação entre JavaScript ambientes, o SDK e o Amazon Transcribe\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/code-samples-transcribe.png)


A JavaScript API do Amazon Transcribe é exposta por meio da [TranscribeService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/Transcribe/)classe cliente.

**Topics**
+ [Exemplos do Amazon Transcribe](transcribe-examples-section.md)
+ [Exemplos do Amazon Transcribe Medical](transcribe-medical-examples-section.md)

# Exemplos do Amazon Transcribe
<a name="transcribe-examples-section"></a>

Neste exemplo, uma série de módulos do Node.js é usada para criar, listar e excluir trabalhos de transcrição que usam os seguintes métodos da classe de cliente do `TranscribeService`:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Para obter mais informações sobre usuários do Amazon Transcribe, consulte o [Guia do desenvolvedor do Amazon Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Tarefas de pré-requisito
<a name="transcribe-example-transcription-jobs"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Começar um trabalho do Amazon Transcribe
<a name="transcribe-start-transcription"></a>

Este exemplo demonstra como iniciar um trabalho de transcrição do Amazon Transcribe usando o AWS SDK para JavaScript. Para obter mais informações, consulte [StartTranscriptionJobCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/).

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `transcribeClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Transcribe. *REGION*Substitua pela sua AWS região.

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crie um módulo do Node.js com o nome de arquivo `transcribe-create-job.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto de parâmetros, especificando os parâmetros necessários. Inicie o trabalho usando o comando `StartMedicalTranscriptionJobCommand`.

**nota**  
*MEDICAL\$1JOB\$1NAME*Substitua por um nome para o trabalho de transcrição. Para *OUTPUT\$1BUCKET\$1NAME* especificar o bucket do Amazon S3 em que a saída é salva. Para *JOB\$1TYPE* especificar tipos de trabalho. Para *SOURCE\$1LOCATION* especificar a localização do arquivo de origem. Para *SOURCE\$1FILE\$1LOCATION* especificar a localização do arquivo de mídia de entrada.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME",
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_LOCATION",
    // For example, "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
  OutputBucketName: "OUTPUT_BUCKET_NAME",
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new StartTranscriptionJobCommand(params),
    );
    console.log("Success - put", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node transcribe-create-job.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_job.js).

## Listar trabalhos do Amazon Transcribe
<a name="transcribe-list-jobs"></a>

Este exemplo mostra como listar os trabalhos de transcrição do Amazon Transcribe usando o AWS SDK para JavaScript. Para obter mais informações sobre quais outras configurações você pode modificar, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/).

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `transcribeClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Transcribe. *REGION*Substitua pela sua AWS região.

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crie um módulo do Node.js com o nome de arquivo `transcribe-list-jobs.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto de parâmetros com os parâmetros necessários.

**nota**  
*KEY\$1WORD*Substitua por uma palavra-chave que o nome do trabalho retornado deve conter.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Not required. Returns only transcription
  // job names containing this string
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new ListTranscriptionJobsCommand(params),
    );
    console.log("Success", data.TranscriptionJobSummaries);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node transcribe-list-jobs.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_jobs.js).

## Exclusão de um trabalho do Amazon Transcribe
<a name="transcribe-delete-job"></a>

Este exemplo mostra como excluir um trabalho de transcrição do Amazon Transcribe usando o AWS SDK para JavaScript. Para obter mais informações sobre comandos opcionais, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/).

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `transcribeClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Transcribe. *REGION*Substitua pela sua AWS região.

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crie um módulo do Node.js com o nome de arquivo `transcribe-delete-job.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Especifique a AWS região e o nome do trabalho que você deseja excluir.

**nota**  
*JOB\$1NAME*Substitua pelo nome do trabalho a ser excluído. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME", // Required. For example, 'transciption_demo'
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new DeleteTranscriptionJobCommand(params),
    );
    console.log("Success - deleted");
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node transcribe-delete-job.js  
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_job.js).

# Exemplos do Amazon Transcribe Medical
<a name="transcribe-medical-examples-section"></a>

Neste exemplo, uma série de módulos do Node.js é usada para criar, listar e excluir trabalhos de transcrição médica que usam os seguintes métodos da classe de cliente do `TranscribeService`:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Para obter mais informações sobre usuários do Amazon Transcribe, consulte o [Guia do desenvolvedor do Amazon Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Tarefas de pré-requisito
<a name="transcribe-example-transcription-medical-jobs"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).  
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Como iniciar um trabalho de transcrição no Amazon Transcribe Medical
<a name="transcribe-start-medical-transcription"></a>

Este exemplo demonstra como iniciar um trabalho de transcrição Amazon Transcribe Medical usando o AWS SDK para JavaScript. Para obter mais informações, consulte [startMedicalTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/).

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `transcribeClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Transcribe. *REGION*Substitua pela sua AWS região.

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crie um módulo do Node.js com o nome de arquivo `transcribe-create-medical-job.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto de parâmetros, especificando os parâmetros necessários. Inicie o trabalho médico usando o comando `StartMedicalTranscriptionJobCommand`.

**nota**  
*MEDICAL\$1JOB\$1NAME*Substitua por um nome para o trabalho de transcrição médica. Para *OUTPUT\$1BUCKET\$1NAME* especificar o bucket do Amazon S3 em que a saída é salva. Para *JOB\$1TYPE* especificar tipos de trabalho. Para *SOURCE\$1LOCATION* especificar a localização do arquivo de origem. Para *SOURCE\$1FILE\$1LOCATION* especificar a localização do arquivo de mídia de entrada.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // Required
  OutputBucketName: "OUTPUT_BUCKET_NAME", // Required
  Specialty: "PRIMARYCARE", // Required. Possible values are 'PRIMARYCARE'
  Type: "JOB_TYPE", // Required. Possible values are 'CONVERSATION' and 'DICTATION'
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_FILE_LOCATION",
    // The S3 object location of the input media file. The URI must be in the same region
    // as the API endpoint that you are calling.For example,
    // "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new StartMedicalTranscriptionJobCommand(params),
    );
    console.log("Success - put", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node transcribe-create-medical-job.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_medical_job.js).

## Como lista trabalhos do Amazon Transcribe Medical
<a name="transcribe-list-medical-jobs"></a>

Este exemplo mostra como listar os trabalhos de transcrição do Amazon Transcribe usando o AWS SDK para JavaScript. Para obter mais informações, consulte [ListTranscriptionMedicalJobsCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListMedicalTranscriptionJobsCommand/).

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `transcribeClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Transcribe. *REGION*Substitua pela sua AWS região.

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crie um módulo do Node.js com o nome de arquivo `transcribe-list-medical-jobs.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto de parâmetros com os parâmetros necessários e liste os trabalhos médicos usando o comando `ListMedicalTranscriptionJobsCommand`.

**nota**  
*KEYWORD*Substitua por uma palavra-chave que o nome do trabalho retornado deve conter.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListMedicalTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Returns only transcription job names containing this string
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new ListMedicalTranscriptionJobsCommand(params),
    );
    console.log("Success", data.MedicalTranscriptionJobName);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node transcribe-list-medical-jobs.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_medical_jobs.js).

## Exclusão de um trabalho do Amazon Transcribe Medical
<a name="transcribe-delete-medical-job"></a>

Este exemplo mostra como excluir um trabalho de transcrição do Amazon Transcribe usando o AWS SDK para JavaScript. Para obter mais informações sobre comandos opcionais, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/).

Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `transcribeClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon Transcribe. *REGION*Substitua pela sua AWS região.

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crie um módulo do Node.js com o nome de arquivo `transcribe-delete-job.js`. Certifique-se de configurar o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários. Crie um objeto de parâmetros com os parâmetros necessários e exclua o trabalho médico usando o comando `DeleteMedicalJobCommand`.

**nota**  
*JOB\$1NAME*Substitua pelo nome do trabalho a ser excluído. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // For example, 'medical_transciption_demo'
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new DeleteMedicalTranscriptionJobCommand(params),
    );
    console.log("Success - deleted");
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Para executar o exemplo, digite o seguinte no prompt de comando.

```
node transcribe-delete-medical-job.js
```

Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_medical_job.js).

# Configuração do Node.js em uma instância do Amazon EC2
<a name="setting-up-node-on-ec2-instance"></a>

Um cenário comum para usar o Node.js com o SDK JavaScript é configurar e executar um aplicativo web Node.js em uma instância do Amazon Elastic Compute Cloud (Amazon EC2). Neste tutorial, você criará uma instância do Linux; conecte-se a ela usando o SSH e instale o Node.js para rodar nessa instância. 

## Pré-requisitos
<a name="setting-up-node-on-ec2-instance.prerequisites"></a>

Este tutorial pressupõe que você já tenha iniciado uma instância do Linux com um nome DNS público que possa ser acessado na Internet e ao qual você possa se conectar usando o SSH. Para obter mais informações, consulte [Etapa 1: iniciar uma instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-launch-instance) no *Guia do usuário do Amazon EC2.*

**Importante**  
Use a imagem de máquina da Amazon (AMI) do **Amazon Linux 2023** ao iniciar uma nova instância do Amazon EC2.

Você também precisa ter configurado o grupo de segurança para permitir as conexões `SSH` (porta 22), ` HTTP` (porta 80) e `HTTPS` (porta 443). Para obter mais informações sobre esses pré-requisitos, consulte [Configuração com o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html) no *Guia do usuário do Amazon EC2*.

## Procedimento
<a name="setting-up-node-on-ec2-instance-procedure"></a>

O procedimento a seguir ajuda você a instalar o Node.js em uma instância do Amazon Linux. Você pode usar esse servidor para hospedar um aplicativo web do Node.js.

**Para configurar o Node.js em sua instância do Linux:**

1. Conecte-se à sua instância do Linux como `ec2-user` usando SSH.

1. Instale o gerenciador de versão do nó (`nvm`) digitando o seguinte na linha de comando.
**Atenção**  
AWS não controla o código a seguir. Antes de executar, certifique-se de verificar sua autenticidade e integridade. Mais informações sobre esse código podem ser encontradas no repositório [nvm.](https://github.com/nvm-sh/nvm/blob/master/README.md) GitHub

   ```
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
   ```

   Usaremos o `nvm` para instalar o Node.js, pois o `nvm` pode instalar várias versões do Node.js e permitir que você alterne entre elas.

1. Para carregar o `nvm`, digite o seguinte na linha de comando:

   ```
   source ~/.bashrc
   ```

1. Use o nvm para instalar a versão do LTS mais recente do Node.js digitando o seguinte na linha de comando.

   ```
   nvm install --lts
   ```

   Instalar o Node.js também instala o gerenciador de pacotes do nó (`npm`) para que você possa instalar módulos adicionais, conforme necessário.

1. Verifique se o Node.js está instalado e funcionando corretamente ao digitar o seguinte na linha de comando.

   ```
   node -e "console.log('Running Node.js ' + process.version)"
   ```

   Isso exibe a seguinte mensagem que mostra a versão do Node.js em execução.

    `Running Node.js VERSION` 

**nota**  
A instalação do nó se aplica somente à sessão atual do Amazon EC2. Se você reiniciar sua sessão de CLI, precisará usar o nvm novamente para habilitar a versão do nó instalada. Se a instância for concluída, você precisará instalar o nó novamente. A alternativa é criar uma imagem de máquina da Amazon (AMI) da instância do Amazon EC2 assim que você tiver a configuração que deseja manter, conforme descrito no tópico a seguir.

## Criar uma imagem de máquina da Amazon (AMI)
<a name="setting-up-node-on-ec2-instance-create-image"></a>

Depois de instalar o Node.js em uma instância do Amazon EC2, você pode criar uma imagem de máquina da Amazon (AMI) a partir dessa instância. A criação de uma AMI facilita o provisionamento de várias instâncias do Amazon EC2 com a mesma instalação do Node.js. Para obter mais informações sobre como criar uma AMI de uma instância existente, consulte [Criação de uma AMI baseada no Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) no *Guia de usuário do Amazon EC2*.

## Recursos relacionados
<a name="setting-up-node-on-ec2-instance-related-resource"></a>

Para obter mais informações sobre os comandos e o software usados neste tópico, consulte as seguintes páginas da Web:
+ Gerenciador de versões do Node (`nvm`) — Veja o repositório [nvm ativado. GitHub](https://github.com/creationix/nvm)
+ gerenciador de pacotes do nó (`npm`): consulte o [site do npm](https://www.npmjs.com).

# Invocar o Lambda com o API Gateway
<a name="api-gateway-invoking-lambda-example"></a>

Você pode invocar uma função Lambda usando o Amazon API Gateway, que é AWS um serviço para criar, publicar, manter, monitorar e proteger REST, WebSocket APIs HTTP e em grande escala. Os desenvolvedores de API podem criar APIs esse acesso AWS ou outros serviços da web, bem como dados armazenados na AWS nuvem. Como desenvolvedor do API Gateway, você pode criar APIs para uso em seus próprios aplicativos cliente. Para obter mais informações, consulte [O que é o Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html). 

AWS Lambda é um serviço de computação que permite executar código sem provisionar ou gerenciar servidores. Você pode criar funções do Lambda em várias linguagens de programação. Para obter mais informações sobre AWS Lambda, consulte [O que é AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

Neste exemplo, você cria uma função Lambda usando a API de tempo de execução do JavaScript Lambda. Este exemplo invoca AWS serviços diferentes para realizar um caso de uso específico. Por exemplo, suponha que uma organização envie uma mensagem de SMS para seus funcionários parabenizando-os pela data de um ano de tempo de casa, conforme mostrado nesta ilustração.

![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


O exemplo levará aproximadamente 20 minutos para ser concluído.

Este exemplo mostra como usar a JavaScript lógica para criar uma solução que execute esse caso de uso. Por exemplo, você aprenderá como ler um banco de dados para determinar quais funcionários atingiram a data de um ano de tempo de casa, como processar os dados e enviar uma mensagem de texto usando uma função do Lambda. Em seguida, você aprenderá a usar o API Gateway para invocar essa AWS Lambda função usando um endpoint Rest. Por exemplo, você pode invocar a função do Lambda usando este comando curl:

```
curl -XGET "https://xxxxqjko1o3.execute-api.us-east-1.amazonaws.com/cronstage/employee" 
```

Este AWS tutorial usa uma tabela do Amazon DynamoDB chamada Employee que contém esses campos.
+ **id** - a chave primária da tabela.
+ **firstName** - o nome do funcionário.
+ **phone** - o número de telefone do funcionário.
+ **startDate** - a data de início do funcionário.

![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**Importante**  
Custo de conclusão: os AWS serviços incluídos neste documento estão incluídos no nível AWS gratuito. No entanto, certifique-se de encerrar todos os recursos depois de concluir este exemplo para garantir que você não seja cobrado.

**Para criar o aplicativo:**

1. [Concluir os pré-requisitos ](#api-gateway-invoking-lambda-provision-resources)

1. [Crie os AWS recursos](#api-gateway-invoking-lambda-provision-resources)

1. [Preparar o script do navegador ](#api-gateway-invoking-lambda-browser-script)

1. [Criar e carregar a função do Lambda ](#api-gateway-invoking-lambda-browser-script)

1. [Implantar a função do Lambda ](#api-gateway-invoking-lambda-deploy-function)

1. [Executar o aplicativo](#api-gateway-invoking-lambda-run)

1. [Excluir os recursos](#api-gateway-invoking-lambda-destroy)

## Tarefas de pré-requisito
<a name="api-gateway-invoking-lambda-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

## Crie os AWS recursos
<a name="api-gateway-invoking-lambda-provision-resources"></a>

Este tutorial requer os seguintes recursos:
+ Uma tabela do Amazon DynamoDB chamada `Employee` com uma chave chamada `Id` e os campos mostrados na ilustração anterior. Certifique-se de inserir os dados corretos, incluindo um telefone celular válido com o qual você deseja testar esse caso de uso. Para obter mais informações, consulte [Criar uma tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Um perfil do IAM com permissões anexadas para executar funções do Lambda.
+ Um bucket do Amazon S3 para hospedar a função do Lambda.

Você pode criar esses recursos manualmente, mas recomendamos provisionar esses recursos usando o CloudFormation descrito neste tutorial.

### Crie os AWS recursos usando CloudFormation
<a name="api-gateway-invoking-lambda-resources-cli"></a>

CloudFormation permite que você crie e provisione implantações de AWS infraestrutura de forma previsível e repetida. Para obter mais informações sobre CloudFormation, consulte o [Guia AWS CloudFormation do usuário](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para criar a CloudFormation pilha usando o AWS CLI:

1. Instale e configure as instruções a AWS CLI seguir no [Guia AWS CLI do usuário](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Crie um arquivo chamado `setup.yaml` no diretório raiz da pasta do seu projeto e copie o conteúdo [aqui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/setup.yaml) para dentro dele.
**nota**  
O CloudFormation modelo foi gerado usando o AWS CDK disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lambda_using_api_gateway). Para obter mais informações sobre o AWS CDK, consulte o [Guia do AWS Cloud Development Kit (AWS CDK) desenvolvedor](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Execute o comando a seguir na linha de comando, *STACK\$1NAME* substituindo-o por um nome exclusivo para a pilha.
**Importante**  
O nome da pilha deve ser exclusivo dentro de uma AWS região e AWS conta. Você pode especificar até 128 caracteres. São permitidos números e hifens.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obter mais informações sobre os parâmetros do comando `create-stack`, consulte o [Guia de referência de comandos da AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) e o [Guia do usuário do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Em seguida, preencha a tabela seguindo o procedimento [Como preencher a tabela](#api-gateway-invoking-lambda-resources-create-table).

### Como preencher a tabela
<a name="api-gateway-invoking-lambda-resources-create-table"></a>

Para preencher a tabela, primeiro crie um diretório chamado `libs`, nele crie um arquivo chamado `dynamoClient.js` e cole o conteúdo abaixo nesse arquivo. 

```
const { DynamoDBClient } = require ( "@aws-sdk/client-dynamodb" );
// Set the AWS Region.
const REGION = "REGION"; // e.g. "us-east-1"
 // Create an Amazon Lambda service client object.
const dynamoClient = new DynamoDBClient({region:REGION});
module.exports = { dynamoClient };
```

 Esse código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/dynamoClient.js).

Em seguida, crie um arquivo chamado `populate-table.js` no diretório raiz da pasta do seu projeto e copie o conteúdo [aqui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) para dentro dele. Para um dos itens, substitua o valor da propriedade `phone` por um número de celular válido no formato E.164, e o valor de `startDate` pela data de hoje.

Na linha de comando, execute o seguinte comando:

```
node populate-table.js
```

```
const { BatchWriteItemCommand } = require ( "aws-sdk/client-dynamodb" );
const {dynamoClient} = require ( "./libs/dynamoClient" );

// Set the parameters.
export const params = {
  RequestItems: {
    Employees: [
      {
        PutRequest: {
          Item: {
            id: { N: "1" },
            firstName: { S: "Bob" },
            phone: { N: "155555555555654" },
            startDate: { S: "2019-12-20" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "2" },
            firstName: { S: "Xing" },
            phone: { N: "155555555555653" },
            startDate: { S: "2019-12-17" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "55" },
            firstName: { S: "Harriette" },
            phone: { N: "155555555555652" },
            startDate: { S: "2019-12-19" },
          },
        },
      },
    ],
  },
};

export const run = async () => {
  try {
    const data = await dbclient.send(new BatchWriteItemCommand(params));
    console.log("Success", data);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

 Esse código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js).

## Criando a AWS Lambda função
<a name="api-gateway-invoking-lambda-browser-script"></a>

### Como configurar o SDK
<a name="api-gateway-invoking-lambda-configure-sdk"></a>

No diretório `libs`, crie arquivos chamados `snsClient.js` e `lambdaClient.js` e cole o conteúdo abaixo nesses arquivos, respectivamente. 

```
const { SNSClient } = require("@aws-sdk/client-sns");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon SNS service client object.
const snsClient = new SNSClient({ region: REGION });
module.exports = { snsClient };
```

 *REGION*Substitua pela AWS região. Esse código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/snsClient.js).

```
const { LambdaClient } = require("@aws-sdk/client-lambda");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Lambda service client object.
const lambdaClient = new LambdaClient({ region: REGION });
module.exports = { lambdaClient };
```

*REGION*Substitua pela AWS região. Esse código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/lambdaClient.js).

Primeiro, importe os módulos e comandos necessários AWS SDK para JavaScript (v3). Em seguida, calcule a data de hoje e atribua-a a um parâmetro. Em terceiro lugar, crie os parâmetros para `ScanCommand`. *TABLE\$1NAME*Substitua pelo nome da tabela que você criou na [Crie os AWS recursos](#api-gateway-invoking-lambda-provision-resources) seção deste exemplo.

O snippet de código a seguir mostra essa etapa. (Consulte [Como empacotar a função do Lambda](#api-gateway-invoking-lambda-full) para ver o exemplo completo.)

```
const { ScanCommand } = require("@aws-sdk/client-dynamodb");
const { PublishCommand } = require("@aws-sdk/client-sns");
const { snsClient } = require("./libs/snsClient");
const { dynamoClient } = require("./libs/dynamoClient");

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = `${yyyy}-${mm}-${dd}`;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which are the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "Employees",
};
```

### Como escanear a tabela do DynamoDB
<a name="api-gateway-invoking-lambda-scan-table"></a>

Primeiro, crie uma async/await função chamada `sendText` para publicar uma mensagem de texto usando o Amazon SNS`PublishCommand`. Em seguida, adicione um padrão de bloco `try` que verifique a tabela do DynamoDB em busca de funcionários com aniversário de tempo de casa na data de hoje e, em seguida, chame a função `sendText` para enviar uma mensagem de texto a esses funcionários. Se ocorrer um erro, o bloco `catch` será chamado.

O snippet de código a seguir mostra essa etapa. (Consulte [Como empacotar a função do Lambda](#api-gateway-invoking-lambda-full) para ver o exemplo completo.)

```
// Helper function to send message using Amazon SNS.
exports.handler = async () => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      await snsClient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to identify employees with work anniversary today.
    const data = await dynamoClient.send(new ScanCommand(params));
    for (const element of data.Items) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message: `Hi ${element.firstName.S}; congratulations on your work anniversary!`,
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    }
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};
```

### Como empacotar a função do Lambda
<a name="api-gateway-invoking-lambda-full"></a>

Este tópico descreve como agrupar os AWS SDK para JavaScript módulos `mylambdafunction.ts` e os necessários para este exemplo em um arquivo agrupado chamado. `index.js` 

1. Caso ainda não tenha feito isso, siga as instruções descritas em [Tarefas de pré-requisito](#api-gateway-invoking-lambda-prerequisites) para este exemplo para instalar o webpack. 
**nota**  
Para obter informações sobre o *webpack*, consulte [Empacotar aplicativos com o webpack](webpack.md).

1. Execute o seguinte na linha de comando para agrupar o deste JavaScript exemplo em um arquivo chamado`<index.js>`:

   ```
   webpack mylambdafunction.ts --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**Importante**  
A saída é chamada `index.js`. Isso ocorre porque as funções do Lambda precisam ter um manipulador `index.js` para funcionar.

1. Comprima o arquivo de saída empacotado, `index.js`, em um arquivo ZIP chamado `mylambdafunction.zip`.

1. Faça o upload de `mylambdafunction.zip` para o bucket Amazon S3 que você criou no tópico [Crie os AWS recursos](#api-gateway-invoking-lambda-provision-resources) deste tutorial. 

## Implantar a função do Lambda
<a name="api-gateway-invoking-lambda-deploy-function"></a>

Na raiz do projeto, crie um arquivo `lambda-function-setup.ts` e cole o conteúdo abaixo nele.

*BUCKET\$1NAME*Substitua pelo nome do bucket do Amazon S3 para o qual você fez o upload da versão ZIP da sua função Lambda. *ZIP\$1FILE\$1NAME*Substitua pelo nome do nome a versão ZIP da sua função Lambda. *ROLE*Substitua pelo Amazon Resource Number (ARN) da função do IAM que você criou no [Crie os AWS recursos](#api-gateway-invoking-lambda-provision-resources) tópico deste tutorial. *LAMBDA\$1FUNCTION\$1NAME*Substitua por um nome para a função Lambda.

```
// Load the required Lambda client and commands.
const {
  CreateFunctionCommand
} = require ( "@aws-sdk/client-lambda" );
const { lambdaClient} = require ( "./libs/lambdaClient.js );

// Set the parameters.
const params = {
  Code: {
    S3Bucket: "BUCKET_NAME", // BUCKET_NAME
    S3Key: "ZIP_FILE_NAME", // ZIP_FILE_NAME
  },
  FunctionName: "LAMBDA_FUNCTION_NAME",
  Handler: "index.handler",
  Role: "IAM_ROLE_ARN", // IAM_ROLE_ARN; e.g., arn:aws:iam::650138640062:role/v3-lambda-tutorial-lambda-role
  Runtime: "nodejs12.x",
  Description:
    "Scans a DynamoDB table of employee details and using Amazon Simple Notification Services (Amazon SNS) to " +
    "send employees an email on each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambdaClient.send(new CreateFunctionCommand(params));
    console.log("Success", data); // successful response
  } catch (err) {
    console.log("Error", err); // an error occurred
  }
};
run();
```

Insira o seguinte na linha de comando para implantar a função do Lambda.

```
node lambda-function-setup.ts
```

Este exemplo de código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/lambda-function-setup.js).

## Configurar o API Gateway para invocar a função do Lambda
<a name="api-gateway-invoking-lambda-run"></a>

**Para criar o aplicativo:**

1. [Criar a API REST](#api-gateway-invoking-lambda-run-create)

1. [Testar o método do API Gateway](#api-gateway-invoking-lambda-run-test)

1. [Implantar o método do API Gateway](#api-gateway-invoking-lambda-run-deploy)

### Criar a API REST
<a name="api-gateway-invoking-lambda-run-create"></a>

Você pode usar o console do API Gateway para criar um endpoint rest para a função do Lambda. Depois de concluído, você pode invocar a função do Lambda usando uma chamada restful.



1. Inicie uma sessão no [console do Amazon API Gateway](https://console.aws.amazon.com/apigateway).

1. Na API REST, escolha **Criar**.

1. Selecione **Nova API**.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/PicNewAPI.png)

1. Especifique **Funcionário** como o nome da API e forneça uma descrição.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picEmployeeAPI.png)

1. Selecione **Criar API**.

1. Escolha **Recursos** na seção **Funcionário**.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picResources.png)

1. No campo de nome, especifique **employees**.

1. Selecione **Create Resources (Criar recursos)**.

1. No menu suspenso **Ações**, escolha **Criar recursos**.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picCreateResources.png)

1. Escolha **/employees**, selecione **Criar método** no menu **Ações** e selecione **GET** no menu suspenso abaixo de **/employees**. Selecione o ícone de marca de seleção.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGet.png)

1. Escolha **Função do Lambda** e insira **mylambdafunction** como o nome da função do Lambda. Escolha **Salvar**.

### Testar o método do API Gateway
<a name="api-gateway-invoking-lambda-run-test"></a>

Neste ponto do tutorial, você pode testar o método do API Gateway que invoca a função do Lambda **mylambdafunction**. Para testar o método, escolha **Testar**, conforme mostrado na ilustração a seguir.

![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picTest.png)


Depois que a função do Lambda é invocada, você pode visualizar o arquivo de log para ver uma mensagem de sucesso.

### Implantar o método do API Gateway
<a name="api-gateway-invoking-lambda-run-deploy"></a>

Após o teste bem-sucedido, você pode implantar o método do [console do Amazon API Gateway](https://console.aws.amazon.com/apigateway).

1. Selecione **GET**.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGetDeploy.png)

1. No menu suspenso **Ações**, selecione **Implantar API**.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1. Preencha o formulário **Implantar API** e escolha **Implantar**.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1.  Escolha **Salvar alterações**.

1.  Escolha **Get** novamente e observe que o URL muda. Esse é o URL de invocação que você pode usar para invocar a função do Lambda.  
![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picURL2.png)

## Excluir os recursos
<a name="api-gateway-invoking-lambda-destroy"></a>

Parabéns\$1 Você invocou uma função do Lambda por meio do Amazon API Gateway usando o AWS SDK para JavaScript. Conforme informado no início deste tutorial, certifique-se de encerrar todos os recursos que criar enquanto percorre este tutorial para garantir que você não seja cobrado. Você pode fazer isso excluindo a CloudFormation pilha que você criou no [Crie os AWS recursos](#api-gateway-invoking-lambda-provision-resources) tópico deste tutorial, da seguinte forma:

1. Abra o [CloudFormation no console AWS de gerenciamento]( https://console.aws.amazon.com/cloudformation/home).

1. Abra a página **Pilhas** e selecione a pilha.

1. Escolha **Excluir**.

# Criação de eventos agendados para executar AWS Lambda funções
<a name="scheduled-events-invoking-lambda-example"></a>

Você pode criar um evento agendado que invoca uma AWS Lambda função usando um evento da Amazon CloudWatch . Você pode configurar um CloudWatch evento para usar uma expressão cron para agendar quando uma função Lambda é invocada. Por exemplo, você pode agendar um CloudWatch evento para invocar uma função Lambda todos os dias da semana.

AWS Lambda é um serviço de computação que permite executar código sem provisionar ou gerenciar servidores. Você pode criar funções do Lambda em várias linguagens de programação. Para obter mais informações sobre AWS Lambda, consulte [O que é AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

Neste tutorial, você cria uma função Lambda usando a API de tempo de execução do JavaScript Lambda. Este exemplo invoca AWS serviços diferentes para realizar um caso de uso específico. Por exemplo, suponha que uma organização envie uma mensagem de SMS para seus funcionários parabenizando-os pela data de um ano de tempo de casa, conforme mostrado nesta ilustração.

![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


O tutorial levará aproximadamente 20 minutos para ser concluído.

Este tutorial mostra como usar a JavaScript lógica para criar uma solução que execute esse caso de uso. Por exemplo, você aprenderá como ler um banco de dados para determinar quais funcionários atingiram a data de um ano de tempo de casa, como processar os dados e enviar uma mensagem de texto usando uma função do Lambda. Em seguida, você aprenderá como usar uma expressão cron para invocar a função do Lambda todos os dias da semana.

Este AWS tutorial usa uma tabela do Amazon DynamoDB chamada Employee que contém esses campos.
+ **id** - a chave primária da tabela.
+ **firstName** - o nome do funcionário.
+ **phone** - o número de telefone do funcionário.
+ **startDate** - a data de início do funcionário.

![\[Tabela DynamoDB\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**Importante**  
Custo de conclusão: os AWS serviços incluídos neste documento estão incluídos no nível AWS gratuito. No entanto, certifique-se de encerrar todos os recursos depois de concluir este tutorial para garantir que você não seja cobrado.

**Para criar o aplicativo:**

1. [Concluir os pré-requisitos ](#scheduled-events-invoking-lambda-provision-resources)

1. [Crie os AWS recursos](#scheduled-events-invoking-lambda-provision-resources)

1. [Preparar o script do navegador ](#scheduled-events-invoking-lambda-browser-script)

1. [Criar e carregar a função do Lambda ](#scheduled-events-invoking-lambda-browser-script)

1. [Implantar a função do Lambda ](#scheduled-events-invoking-lambda-deploy-function)

1. [Executar o aplicativo](#scheduled-events-invoking-lambda-run)

1. [Excluir os recursos](#scheduled-events-invoking-lambda-destroy)

## Tarefas de pré-requisito
<a name="scheduled-events-invoking-lambda-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node.js e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

## Crie os AWS recursos
<a name="scheduled-events-invoking-lambda-provision-resources"></a>

Este tutorial requer os seguintes recursos:
+ Uma tabela do Amazon DynamoDB chamada **Employee** com uma chave chamada **Id** e os campos mostrados na ilustração anterior. Certifique-se de inserir os dados corretos, incluindo um telefone celular válido com o qual você deseja testar esse caso de uso. Para obter mais informações, consulte [Criar uma tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Um perfil do IAM com permissões anexadas para executar funções do Lambda.
+ Um bucket do Amazon S3 para hospedar a função do Lambda.

Você pode criar esses recursos manualmente, mas recomendamos provisionar esses recursos usando o CloudFormation descrito neste tutorial.

### Crie os AWS recursos usando CloudFormation
<a name="scheduled-events-invoking-lambda-resources-cli"></a>

CloudFormation permite que você crie e provisione implantações de AWS infraestrutura de forma previsível e repetida. Para obter mais informações sobre CloudFormation, consulte o [Guia AWS CloudFormation do usuário](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para criar a CloudFormation pilha usando o AWS CLI:

1. Instale e configure as instruções a AWS CLI seguir no [Guia AWS CLI do usuário](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Crie um arquivo chamado `setup.yaml` no diretório raiz da pasta do seu projeto e copie o conteúdo [aqui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/setup.yaml) para dentro dele.
**nota**  
O CloudFormation modelo foi gerado usando o AWS CDK disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/lambda_using_scheduled_events). Para obter mais informações sobre o AWS CDK, consulte o [Guia do AWS Cloud Development Kit (AWS CDK) desenvolvedor](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Execute o comando a seguir na linha de comando, *STACK\$1NAME* substituindo-o por um nome exclusivo para a pilha.
**Importante**  
O nome da pilha deve ser exclusivo dentro de uma AWS região e AWS conta. Você pode especificar até 128 caracteres. São permitidos números e hifens.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obter mais informações sobre os parâmetros do comando `create-stack`, consulte o [Guia de referência de comandos da AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) e o [Guia do usuário do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Veja uma lista dos recursos no console abrindo a pilha no CloudFormation painel e escolhendo a guia **Recursos**. Você precisa desses recursos para o tutorial. 

1. Quando a pilha for criada, use o AWS SDK para JavaScript para preencher a tabela do DynamoDB, conforme descrito em. [Preencher a tabela do DynamoDB.](#scheduled-events-invoking-lambda-resources-create-table)

### Preencher a tabela do DynamoDB.
<a name="scheduled-events-invoking-lambda-resources-create-table"></a>

Para preencher a tabela, primeiro crie um diretório chamado `libs`, nele crie um arquivo chamado `dynamoClient.js` e cole o conteúdo abaixo nesse arquivo. 

```
const { DynamoDBClient } = require( "@aws-sdk/client-dynamodb" );
// Set the AWS Region.
const REGION = "REGION"; // e.g. "us-east-1"
// Create an Amazon DynamoDB service client object.
const dynamoClient = new DynamoDBClient({region:REGION});
module.exports = { dynamoClient };
```

 Esse código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/libs/dynamoClient.js).

Em seguida, crie um arquivo chamado `populate-table.js` no diretório raiz da pasta do seu projeto e copie o conteúdo [aqui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) para dentro dele. Para um dos itens, substitua o valor da propriedade `phone` por um número de celular válido no formato E.164, e o valor de `startDate` pela data de hoje.

Na linha de comando, execute o seguinte comando:

```
node populate-table.js
```

```
const {
BatchWriteItemCommand } = require( "aws-sdk/client-dynamodb" );
const {dynamoClient} = require(  "./libs/dynamoClient" );
// Set the parameters.
const params = {
  RequestItems: {
    Employees: [
      {
        PutRequest: {
          Item: {
            id: { N: "1" },
            firstName: { S: "Bob" },
            phone: { N: "155555555555654" },
            startDate: { S: "2019-12-20" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "2" },
            firstName: { S: "Xing" },
            phone: { N: "155555555555653" },
            startDate: { S: "2019-12-17" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "55" },
            firstName: { S: "Harriette" },
            phone: { N: "155555555555652" },
            startDate: { S: "2019-12-19" },
          },
        },
      },
    ],
  },
};

export const run = async () => {
  try {
    const data = await dbclient.send(new BatchWriteItemCommand(params));
    console.log("Success", data);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

 Esse código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/helper-functions/populate-table.js).

## Criando a AWS Lambda função
<a name="scheduled-events-invoking-lambda-browser-script"></a>

### Como configurar o SDK
<a name="scheduled-events-invoking-lambda-configure-sdk"></a>

Primeiro, importe os módulos e comandos necessários AWS SDK para JavaScript (v3): o `ScanCommand` DynamoDB `DynamoDBClient` e `SNSClient` o comando Amazon SNS. `PublishCommand` *REGION*Substitua pela AWS região. Em seguida, calcule a data de hoje e atribua-a a um parâmetro. Em seguida, crie os parâmetros para o `ScanCommand` .Replace *TABLE\$1NAME* com o nome da tabela que você criou na [Crie os AWS recursos](#scheduled-events-invoking-lambda-provision-resources) seção deste exemplo.

O snippet de código a seguir mostra essa etapa. (Consulte [Como empacotar a função do Lambda](#scheduled-events-invoking-lambda-full) para ver o exemplo completo.)

```
"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = yyyy + "-" + mm + "-" + dd;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};
```

### Como escanear a tabela do DynamoDB
<a name="scheduled-events-invoking-lambda-scan-table"></a>

Primeiro, crie uma async/await função chamada `sendText` para publicar uma mensagem de texto usando o Amazon SNS`PublishCommand`. Em seguida, adicione um padrão de bloco `try` que verifique a tabela do DynamoDB em busca de funcionários com aniversário de tempo de casa na data de hoje e, em seguida, chame a função `sendText` para enviar uma mensagem de texto a esses funcionários. Se ocorrer um erro, o bloco `catch` será chamado.

O snippet de código a seguir mostra essa etapa. (Consulte [Como empacotar a função do Lambda](#scheduled-events-invoking-lambda-full) para ver o exemplo completo.)

```
exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message:
          "Hi " +
          element.firstName.S +
          "; congratulations on your work anniversary!",
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    });
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};
```

### Como empacotar a função do Lambda
<a name="scheduled-events-invoking-lambda-full"></a>

Este tópico descreve como agrupar os AWS SDK para JavaScript módulos `mylambdafunction.js` e os necessários para este exemplo em um arquivo agrupado chamado. `index.js` 

1. Caso ainda não tenha feito isso, siga as instruções descritas em [Tarefas de pré-requisito](#scheduled-events-invoking-lambda-prerequisites) para este exemplo para instalar o webpack. 
**nota**  
Para obter informações sobre o *webpack*, consulte [Empacotar aplicativos com o webpack](webpack.md).

1. Execute o seguinte na linha de comando para agrupar o deste JavaScript exemplo em um arquivo chamado`<index.js>`:

   ```
   webpack mylamdbafunction.js --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**Importante**  
A saída é chamada `index.js`. Isso ocorre porque as funções do Lambda precisam ter um manipulador `index.js` para funcionar.

1. Comprima o arquivo de saída empacotado, `index.js`, em um arquivo ZIP chamado `my-lambda-function.zip`.

1. Faça o upload de `mylambdafunction.zip` para o bucket Amazon S3 que você criou no tópico [Crie os AWS recursos](#scheduled-events-invoking-lambda-provision-resources) deste tutorial. 

Aqui está o código completo do script do navegador para `mylambdafunction.js`.

```
"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = yyyy + "-" + mm + "-" + dd;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};

// Create the client service objects.
const dbclient = new DynamoDBClient({ region: REGION });
const snsclient = new SNSClient({ region: REGION });

exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message:
          "Hi " +
          element.firstName.S +
          "; congratulations on your work anniversary!",
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    });
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};
```

## Implantar a função do Lambda
<a name="scheduled-events-invoking-lambda-deploy-function"></a>

Na raiz do projeto, crie um arquivo `lambda-function-setup.js` e cole o conteúdo abaixo nele.

*BUCKET\$1NAME*Substitua pelo nome do bucket do Amazon S3 para o qual você fez o upload da versão ZIP da sua função Lambda. *ZIP\$1FILE\$1NAME*Substitua pelo nome do nome a versão ZIP da sua função Lambda. *IAM\$1ROLE\$1ARN*Substitua pelo Amazon Resource Number (ARN) da função do IAM que você criou no [Crie os AWS recursos](#scheduled-events-invoking-lambda-provision-resources) tópico deste tutorial. *LAMBDA\$1FUNCTION\$1NAME*Substitua por um nome para a função Lambda.

```
// Load the required Lambda client and commands.
const {
   CreateFunctionCommand,
} = require("@aws-sdk/client-lambda");
const {
   lambdaClient
} = require("..libs/lambdaClient.js");

// Instantiate an Lambda client service object.
const lambda = new LambdaClient({ region: REGION });

// Set the parameters.
const params = {
  Code: {
    S3Bucket: "BUCKET_NAME", // BUCKET_NAME
    S3Key: "ZIP_FILE_NAME", // ZIP_FILE_NAME
  },
  FunctionName: "LAMBDA_FUNCTION_NAME",
  Handler: "index.handler",
  Role: "IAM_ROLE_ARN", // IAM_ROLE_ARN; e.g., arn:aws:iam::650138640062:role/v3-lambda-tutorial-lambda-role
  Runtime: "nodejs12.x",
  Description:
    "Scans a DynamoDB table of employee details and using Amazon Simple Notification Services (Amazon SNS) to " +
    "send employees an email the each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambda.send(new CreateFunctionCommand(params));
    console.log("Success", data); // successful response
  } catch (err) {
    console.log("Error", err); // an error occurred
  }
};
run();
```

Insira o seguinte na linha de comando para implantar a função do Lambda.

```
node lambda-function-setup.js
```

Este exemplo de código está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/helper-functions/lambda-function-setup.js).

## Configure CloudWatch para invocar as funções Lambda
<a name="scheduled-events-invoking-lambda-run"></a>

Para configurar para CloudWatch invocar as funções do Lambda:

1. Abra a **página Functions (Funções)** no console do Lambda.

1. Escolha a função Lambda.

1. Em **Designer**, escolha **Add trigger (Adicionar trigger)**.

1. Defina o tipo de gatilho como **CloudWatch Events/ EventBridge**.

1. Em Regra, escolha **Criar uma nova regra**.

1.  Preencha o Nome da regra e a Descrição da regra.

1. Para o tipo de regra, selecione **Expressão de programação**.

1. No campo **Expressão de programação**, insira uma expressão cron. Por exemplo, **cron(0 12 ? \$1 MON-FRI \$1)**.

1. Escolha **Adicionar**.
**nota**  
Para obter mais informações, consulte [Usando o Lambda com CloudWatch eventos](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html).

## Excluir os recursos
<a name="scheduled-events-invoking-lambda-destroy"></a>

Parabéns\$1 Você invocou uma função Lambda por meio de eventos programados da CloudWatch Amazon usando o. AWS SDK para JavaScript Conforme informado no início deste tutorial, certifique-se de encerrar todos os recursos que criar enquanto percorre este tutorial para garantir que você não seja cobrado. Você pode fazer isso excluindo a CloudFormation pilha que você criou no [Crie os AWS recursos](#scheduled-events-invoking-lambda-provision-resources) tópico deste tutorial, da seguinte forma:

1. Abra o [console do CloudFormation]( https://console.aws.amazon.com/cloudformation/home).

1. Na página **Pilhas**, selecione a pilha.

1. Escolha **Excluir**.

# Criar um chatbot do Amazon Lex
<a name="lex-bot-example"></a>

Você pode criar um chatbot do Amazon Lex em um aplicativo Web para engajar os visitantes do seu site. Um chatbot do Amazon Lex é uma funcionalidade que realiza conversas de chat online com os usuários sem fornecer contato direto com uma pessoa. Por exemplo, a ilustração a seguir mostra um chatbot do Amazon Lex que envolve um usuário para reservar um quarto de hotel.

![\[Chatbot interface demonstrating a hotel booking conversation with user inputs and bot responses.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/lex_example/chatintro.png)


O chatbot Amazon Lex criado neste AWS tutorial é capaz de lidar com vários idiomas. Por exemplo, um usuário que fala francês pode inserir um texto em francês e receber uma resposta em francês.

![\[Chatbot interface demonstrating Amazon Lex integration with French language support.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot2.png)


Da mesma forma, um usuário pode se comunicar com o chatbot do Amazon Lex em italiano.

![\[Chat interface showing Italian language exchange between user and Amazon Lex chatbot.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot3.png)


Este AWS tutorial orienta você na criação de um chatbot do Amazon Lex e na integração dele a um aplicativo web Node.js. O AWS SDK para JavaScript (v3) é usado para invocar esses AWS serviços:
+ Amazon Lex
+ Amazon Comprehend
+ Amazon Translate

**Custo de conclusão:** os AWS serviços incluídos neste documento estão incluídos no [nível AWS gratuito](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc).

**Observação:** certifique-se de encerrar todos os recursos que você cria ao passar por este tutorial para garantir que você não seja cobrado.

**Para criar o aplicativo:**

1. [Pré-requisitos](#lex-bot-example-prerequisites)

1. [Provisionar recursos](#lex-bot-provision-resources)

1. [Criar um chatbot do Amazon Lex](#lex-bot-example-create-lex-bot)

1. [Criar o HTML](#lex-bot-example-html)

1. [Criar o script do navegador](#lex-bot-example-script)

1. [Próximas etapas](#lex-bot-example-next-steps)

## Pré-requisitos
<a name="lex-bot-example-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.

**Importante**  
Este exemplo usa ECMAScript6 (ES6). Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).  
No entanto, se você preferir usar a sintaxe CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).

## Crie os AWS recursos
<a name="lex-bot-provision-resources"></a>

Este tutorial requer os seguintes recursos:
+ Um perfil do IAM não autenticado com permissões anexadas para:
  + Amazon Comprehend
  + Amazon Translate
  + Amazon Lex

Você pode criar esses recursos manualmente, mas recomendamos provisionar esses recursos usando AWS CloudFormation conforme descrito neste tutorial.

### Crie os AWS recursos usando CloudFormation
<a name="lex-bot-example-resources-cli"></a>

CloudFormation permite que você crie e provisione implantações de AWS infraestrutura de forma previsível e repetida. Para obter mais informações sobre CloudFormation, consulte o [Guia AWS CloudFormation do usuário](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para criar a CloudFormation pilha usando o AWS CLI:

1. Instale e configure as instruções a AWS CLI seguir no [Guia AWS CLI do usuário](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Crie um arquivo chamado `setup.yaml` no diretório raiz da pasta do seu projeto e copie o conteúdo [aqui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/setup.yaml) para dentro dele.
**nota**  
O CloudFormation modelo foi gerado usando o AWS CDK disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lex_bot_example_iam_unauth_role). Para obter mais informações sobre o AWS CDK, consulte o [Guia do AWS Cloud Development Kit (AWS CDK) desenvolvedor](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Execute o comando a seguir na linha de comando, *STACK\$1NAME* substituindo-o por um nome exclusivo para a pilha.
**Importante**  
O nome da pilha deve ser exclusivo dentro de uma AWS região e AWS conta. Você pode especificar até 128 caracteres. São permitidos números e hifens.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obter mais informações sobre os parâmetros do comando `create-stack`, consulte o [Guia de referência de comandos da AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) e o [Guia do usuário do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Para visualizar os recursos criados, abra o console do Amazon Lex, escolha a pilha e selecione a guia **Recursos**.

## Criar um bot do Amazon Lex
<a name="lex-bot-example-create-lex-bot"></a>

**Importante**  
Use a V1 do console do Amazon Lex para criar o bot. Este exemplo não funciona com bots criados usando a V2.

A primeira etapa é criar um chatbot do Amazon Lex usando o Console de Gerenciamento da Amazon Web Services. Neste exemplo, o **BookTrip**exemplo do Amazon Lex é usado. Para obter mais informações, consulte [Reservar viagem](https://docs.aws.amazon.com/lex/latest/dg/ex-book-trip.html).
+ Faça login no Console de Gerenciamento da Amazon Web Services e abra o console do Amazon Lex no [Console da Amazon Web Services](https://console.aws.amazon.com/lex/).
+ Na página Bots, selecione **Criar**.
+ Escolha o **BookTrip**blueprint (deixe o nome padrão do bot **BookTrip**).  
![\[Interface for creating a chatbot, showing BookTrip sample with conversation flow and components.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/lex_example/pic2.png)
+ Preencha as configurações padrão e escolha **Criar** (o console mostra o **BookTrip**bot). Na guia Editor, analise os detalhes das intenções pré-configuradas.
+ Teste o bot na janela de teste. Comece o teste digitando *Quero reservar um quarto de hotel*.  
![\[Chat interface showing a hotel booking conversation with a bot asking for the city.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/lex_example/ChatBotTest.png)
+ Escolha **Publicar** e especifique um nome de alias (você precisará desse valor ao usar o AWS SDK para JavaScript).

**nota**  
 Você precisa referenciar o **nome** e o **alias do bot** em seu JavaScript código.

## Criar o HTML
<a name="lex-bot-example-html"></a>

Crie um arquivo chamado `index.html`. Copie e cole o código abaixo em`index.html`. Esse HTML faz referência a `main.js`. Essa é uma versão integrada do index.js, que inclui os AWS SDK para JavaScript módulos necessários. Você criará esse arquivo em [Criar o HTML](#lex-bot-example-html). `index.html` também faz referência a `style.css`, o qual adiciona os estilos. 

```
<!doctype html>
<head>
  <title>Amazon Lex - Sample Application (BookTrip)</title>
  <link type="text/css" rel="stylesheet" href="style.css" />
</head>

<body>
  <h1 id="title">Amazon Lex - BookTrip</h1>
  <p id="intro">
    This multiple language chatbot shows you how easy it is to incorporate
    <a
      href="https://aws.amazon.com/lex/"
      title="Amazon Lex (product)"
      target="_new"
      >Amazon Lex</a
    >
    into your web apps. Try it out.
  </p>
  <div id="conversation"></div>
  <input
    type="text"
    id="wisdom"
    size="80"
    value=""
    placeholder="J'ai besoin d'une chambre d'hôtel"
  />
  <br />
  <button onclick="createResponse()">Send Text</button>
  <script type="text/javascript" src="./main.js"></script>
</body>
```

Esse código também está disponível [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk#running-a-cdk-app).

## Criar o script do navegador
<a name="lex-bot-example-script"></a>

Crie um arquivo chamado `index.js`. Copie e cole o código abaixo em `index.js`. Importe os AWS SDK para JavaScript módulos e comandos necessários. Crie clientes para o Amazon Lex, o Amazon Comprehend e o Amazon Translate. *REGION*Substitua por AWS Região e *IDENTITY\$1POOL\$1ID* pelo ID do grupo de identidades que você criou no[Crie os AWS recursos](#lex-bot-provision-resources). Para recuperar esse ID do banco de identidades, abra o banco de identidades no console do Amazon Cognito, escolha **Editar grupo de identidades** e selecione **Código de exemplo** no menu lateral. O ID do banco de identidades é mostrado em vermelho no console.

Primeiro, crie um diretório `libs` e crie os objetos de cliente de serviço necessários criando três arquivos: `comprehendClient.js`, `lexClient.js` e `translateClient.js`. Cole o código apropriado abaixo em cada um e substitua *REGION* e *IDENTITY\$1POOL\$1ID* em cada arquivo.

**nota**  
Use o ID do banco de identidades do Amazon Cognito que você criou em [Crie os AWS recursos usando CloudFormation](#lex-bot-example-resources-cli).

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { ComprehendClient } from "@aws-sdk/client-comprehend";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Comprehend service client object.
const comprehendClient = new ComprehendClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { comprehendClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { LexRuntimeServiceClient } from "@aws-sdk/client-lex-runtime-service";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Lex service client object.
const lexClient = new LexRuntimeServiceClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { lexClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { TranslateClient } from "@aws-sdk/client-translate";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Translate service client object.
const translateClient = new TranslateClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { translateClient };
```

Esse código está disponível [aqui em GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/libs) .

Em seguida, crie um arquivo `index.js` e cole o código abaixo nele.

 Substitua *BOT\$1ALIAS* e *BOT\$1NAME* pelo alias e nome do seu bot Amazon Lex, respectivamente, e *USER\$1ID* por um ID de usuário. A função assíncrona `createResponse` faz o seguinte:
+ Pega o texto inserido pelo usuário no navegador e usa o Amazon Comprehend para determinar seu código de idioma.
+ Pega o código do idioma e usa o Amazon Translate para traduzir o texto para o inglês.
+ Pega o texto traduzido e usa o Amazon Lex para gerar uma resposta.
+ Publica a resposta na página do navegador.

```
import { DetectDominantLanguageCommand } from "@aws-sdk/client-comprehend";
import { TranslateTextCommand } from "@aws-sdk/client-translate";
import { PostTextCommand } from "@aws-sdk/client-lex-runtime-service";
import { lexClient } from "./libs/lexClient.js";
import { translateClient } from "./libs/translateClient.js";
import { comprehendClient } from "./libs/comprehendClient.js";

let g_text = "";
// Set the focus to the input box.
document.getElementById("wisdom").focus();

function showRequest() {
  const conversationDiv = document.getElementById("conversation");
  const requestPara = document.createElement("P");
  requestPara.className = "userRequest";
  requestPara.appendChild(document.createTextNode(g_text));
  conversationDiv.appendChild(requestPara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function showResponse(lexResponse) {
  const conversationDiv = document.getElementById("conversation");
  const responsePara = document.createElement("P");
  responsePara.className = "lexResponse";

  const lexTextResponse = lexResponse;

  responsePara.appendChild(document.createTextNode(lexTextResponse));
  responsePara.appendChild(document.createElement("br"));
  conversationDiv.appendChild(responsePara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function handletext(text) {
  g_text = text;
  const xhr = new XMLHttpRequest();
  xhr.addEventListener("load", loadNewItems, false);
  xhr.open("POST", "../text", true); // A Spring MVC controller
  xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded"); //necessary
  xhr.send(`text=${text}`);
}

function loadNewItems() {
  showRequest();

  // Re-enable input.
  const wisdomText = document.getElementById("wisdom");
  wisdomText.value = "";
  wisdomText.locked = false;
}

// Respond to user's input.
const createResponse = async () => {
  // Confirm there is text to submit.
  const wisdomText = document.getElementById("wisdom");
  if (wisdomText?.value && wisdomText.value.trim().length > 0) {
    // Disable input to show it is being sent.
    const wisdom = wisdomText.value.trim();
    wisdomText.value = "...";
    wisdomText.locked = true;
    handletext(wisdom);

    const comprehendParams = {
      Text: wisdom,
    };
    try {
      const data = await comprehendClient.send(
        new DetectDominantLanguageCommand(comprehendParams),
      );
      console.log(
        "Success. The language code is: ",
        data.Languages[0].LanguageCode,
      );
      const translateParams = {
        SourceLanguageCode: data.Languages[0].LanguageCode,
        TargetLanguageCode: "en", // For example, "en" for English.
        Text: wisdom,
      };
      try {
        const data = await translateClient.send(
          new TranslateTextCommand(translateParams),
        );
        console.log("Success. Translated text: ", data.TranslatedText);
        const lexParams = {
          botName: "BookTrip",
          botAlias: "mynewalias",
          inputText: data.TranslatedText,
          userId: "chatbot", // For example, 'chatbot-demo'.
        };
        try {
          const data = await lexClient.send(new PostTextCommand(lexParams));
          console.log("Success. Response is: ", data.message);
          const msg = data.message;
          showResponse(msg);
        } catch (err) {
          console.log("Error responding to message. ", err);
        }
      } catch (err) {
        console.log("Error translating text. ", err);
      }
    } catch (err) {
      console.log("Error identifying language. ", err);
    }
  }
};
// Make the function available to the browser.
window.createResponse = createResponse;
```

Esse código está disponível [aqui em GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/index.html) .

Agora use o webpack para agrupar os AWS SDK para JavaScript módulos `index.js` e em um único arquivo,. `main.js`

1. Caso ainda não tenha feito isso, siga as instruções descritas em [Pré-requisitos](#lex-bot-example-prerequisites) para este exemplo para instalar o webpack. 
**nota**  
Para obter informações sobre o *webpack*, consulte [Empacotar aplicativos com o webpack](webpack.md).

1. Execute o seguinte na linha de comando para agrupar o deste JavaScript exemplo em um arquivo chamado`main.js`:

   ```
   webpack index.js --mode development --target web --devtool false -o main.js
   ```

## Próximas etapas
<a name="lex-bot-example-next-steps"></a>

Parabéns\$1 Você criou um aplicativo Node.js que usa o Amazon Lex para criar uma experiência de usuário interativa. Conforme informado no início deste tutorial, certifique-se de encerrar todos os recursos que criar enquanto percorre este tutorial para garantir que você não seja cobrado. Você pode fazer isso excluindo a CloudFormation pilha que você criou no [Crie os AWS recursos](#lex-bot-provision-resources) tópico deste tutorial, da seguinte forma:

1. Abra o [console do CloudFormation]( https://console.aws.amazon.com/cloudformation/home).

1. Na página **Pilhas**, selecione a pilha.

1. Escolha **Excluir**.

Para obter mais exemplos AWS de serviços cruzados, consulte exemplos de [AWS SDK para JavaScript serviços cruzados](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/tutorials.html).