}} props
*/
export async function waitForPipelineComplete({ arn, sagemakerClient, wait }) {
const command = new DescribePipelineExecutionCommand({
PipelineExecutionArn: arn,
});
let complete = false;
const intervalInSeconds = 15;
const COMPLETION_STATUSES = [
PipelineExecutionStatus.FAILED,
PipelineExecutionStatus.STOPPED,
PipelineExecutionStatus.SUCCEEDED,
];
do {
const { PipelineExecutionStatus: status, FailureReason } =
await sagemakerClient.send(command);
complete = COMPLETION_STATUSES.includes(status);
if (!complete) {
console.log(
`Pipeline is ${status}. Waiting ${intervalInSeconds} seconds before checking again.`,
);
await wait(intervalInSeconds);
} else if (status === PipelineExecutionStatus.FAILED) {
throw new Error(`Pipeline failed because: ${FailureReason}`);
} else if (status === PipelineExecutionStatus.STOPPED) {
throw new Error("Pipeline was forcefully stopped.");
} else {
console.log(`Pipeline execution ${status}.`);
}
} while (!complete);
}
/**
* Return the string value of an Amazon S3 object.
* @param {{ bucket: string, key: string, s3Client: import('@aws-sdk/client-s3').S3Client}} param0
*/
export async function getObject({ bucket, s3Client }) {
const prefix = "output/";
const { Contents } = await s3Client.send(
new ListObjectsV2Command({ MaxKeys: 1, Bucket: bucket, Prefix: prefix }),
);
if (!Contents.length) {
throw new Error("No objects found in bucket.");
}
// Find the CSV file.
const outputObject = Contents.find((obj) => obj.Key.endsWith(".csv"));
if (!outputObject) {
throw new Error(`No CSV file found in bucket with the prefix "${prefix}".`);
}
const { Body } = await s3Client.send(
new GetObjectCommand({
Bucket: bucket,
Key: outputObject.Key,
}),
);
return Body.transformToString();
}
```
Esta función es un extracto de un archivo que utiliza las funciones de la biblioteca anterior para configurar una canalización de SageMaker IA, ejecutarla y eliminar todos los recursos creados.
```
import { retry, wait } from "@aws-doc-sdk-examples/lib/utils/util-timers.js";
import {
attachPolicy,
configureLambdaSQSEventSource,
createLambdaExecutionPolicy,
createLambdaExecutionRole,
createLambdaFunction,
createLambdaLayer,
createS3Bucket,
createSQSQueue,
createSagemakerExecutionPolicy,
createSagemakerPipeline,
createSagemakerRole,
getObject,
startPipelineExecution,
uploadCSVDataToS3,
waitForPipelineComplete,
} from "./lib.js";
import { MESSAGES } from "./messages.js";
export class SageMakerPipelinesWkflw {
names = {
LAMBDA_EXECUTION_ROLE: "sagemaker-wkflw-lambda-execution-role",
LAMBDA_EXECUTION_ROLE_POLICY:
"sagemaker-wkflw-lambda-execution-role-policy",
LAMBDA_FUNCTION: "sagemaker-wkflw-lambda-function",
LAMBDA_LAYER: "sagemaker-wkflw-lambda-layer",
SAGE_MAKER_EXECUTION_ROLE: "sagemaker-wkflw-pipeline-execution-role",
SAGE_MAKER_EXECUTION_ROLE_POLICY:
"sagemaker-wkflw-pipeline-execution-role-policy",
SAGE_MAKER_PIPELINE: "sagemaker-wkflw-pipeline",
SQS_QUEUE: "sagemaker-wkflw-sqs-queue",
S3_BUCKET: `sagemaker-wkflw-s3-bucket-${Date.now()}`,
};
cleanUpFunctions = [];
/**
* @param {import("@aws-doc-sdk-examples/lib/prompter.js").Prompter} prompter
* @param {import("@aws-doc-sdk-examples/lib/logger.js").Logger} logger
* @param {{ IAM: import("@aws-sdk/client-iam").IAMClient, Lambda: import("@aws-sdk/client-lambda").LambdaClient, SageMaker: import("@aws-sdk/client-sagemaker").SageMakerClient, S3: import("@aws-sdk/client-s3").S3Client, SQS: import("@aws-sdk/client-sqs").SQSClient }} clients
*/
constructor(prompter, logger, clients) {
this.prompter = prompter;
this.logger = logger;
this.clients = clients;
}
async run() {
try {
await this.startWorkflow();
} catch (err) {
console.error(err);
throw err;
} finally {
this.logger.logSeparator();
const doCleanUp = await this.prompter.confirm({
message: "Clean up resources?",
});
if (doCleanUp) {
await this.cleanUp();
}
}
}
async cleanUp() {
// Run all of the clean up functions. If any fail, we log the error and continue.
// This ensures all clean up functions are run.
for (let i = this.cleanUpFunctions.length - 1; i >= 0; i--) {
await retry(
{ intervalInMs: 1000, maxRetries: 60, swallowError: true },
this.cleanUpFunctions[i],
);
}
}
async startWorkflow() {
this.logger.logSeparator(MESSAGES.greetingHeader);
await this.logger.log(MESSAGES.greeting);
this.logger.logSeparator();
await this.logger.log(
MESSAGES.creatingRole.replace(
"${ROLE_NAME}",
this.names.LAMBDA_EXECUTION_ROLE,
),
);
// Create an IAM role that will be assumed by the AWS Lambda function. This function
// is triggered by Amazon SQS messages and calls SageMaker and SageMaker GeoSpatial actions.
const { arn: lambdaExecutionRoleArn, cleanUp: lambdaExecutionRoleCleanUp } =
await createLambdaExecutionRole({
name: this.names.LAMBDA_EXECUTION_ROLE,
iamClient: this.clients.IAM,
});
// Add a clean up step to a stack for every resource created.
this.cleanUpFunctions.push(lambdaExecutionRoleCleanUp);
await this.logger.log(
MESSAGES.roleCreated.replace(
"${ROLE_NAME}",
this.names.LAMBDA_EXECUTION_ROLE,
),
);
this.logger.logSeparator();
await this.logger.log(
MESSAGES.creatingRole.replace(
"${ROLE_NAME}",
this.names.SAGE_MAKER_EXECUTION_ROLE,
),
);
// Create an IAM role that will be assumed by the SageMaker pipeline. The pipeline
// sends messages to an Amazon SQS queue and puts/retrieves Amazon S3 objects.
const {
arn: pipelineExecutionRoleArn,
cleanUp: pipelineExecutionRoleCleanUp,
} = await createSagemakerRole({
iamClient: this.clients.IAM,
name: this.names.SAGE_MAKER_EXECUTION_ROLE,
wait,
});
this.cleanUpFunctions.push(pipelineExecutionRoleCleanUp);
await this.logger.log(
MESSAGES.roleCreated.replace(
"${ROLE_NAME}",
this.names.SAGE_MAKER_EXECUTION_ROLE,
),
);
this.logger.logSeparator();
// Create an IAM policy that allows the AWS Lambda function to invoke SageMaker APIs.
const {
arn: lambdaExecutionPolicyArn,
policy: lambdaPolicy,
cleanUp: lambdaExecutionPolicyCleanUp,
} = await createLambdaExecutionPolicy({
name: this.names.LAMBDA_EXECUTION_ROLE_POLICY,
s3BucketName: this.names.S3_BUCKET,
iamClient: this.clients.IAM,
pipelineExecutionRoleArn,
});
this.cleanUpFunctions.push(lambdaExecutionPolicyCleanUp);
console.log(JSON.stringify(lambdaPolicy, null, 2), "\n");
await this.logger.log(
MESSAGES.attachPolicy
.replace("${POLICY_NAME}", this.names.LAMBDA_EXECUTION_ROLE_POLICY)
.replace("${ROLE_NAME}", this.names.LAMBDA_EXECUTION_ROLE),
);
await this.prompter.checkContinue();
// Attach the Lambda execution policy to the execution role.
const { cleanUp: lambdaExecutionRolePolicyCleanUp } = await attachPolicy({
roleName: this.names.LAMBDA_EXECUTION_ROLE,
policyArn: lambdaExecutionPolicyArn,
iamClient: this.clients.IAM,
});
this.cleanUpFunctions.push(lambdaExecutionRolePolicyCleanUp);
await this.logger.log(MESSAGES.policyAttached);
this.logger.logSeparator();
// Create Lambda layer for SageMaker packages.
const { versionArn: layerVersionArn, cleanUp: lambdaLayerCleanUp } =
await createLambdaLayer({
name: this.names.LAMBDA_LAYER,
lambdaClient: this.clients.Lambda,
});
this.cleanUpFunctions.push(lambdaLayerCleanUp);
await this.logger.log(
MESSAGES.creatingFunction.replace(
"${FUNCTION_NAME}",
this.names.LAMBDA_FUNCTION,
),
);
// Create the Lambda function with the execution role.
const { arn: lambdaArn, cleanUp: lambdaCleanUp } =
await createLambdaFunction({
roleArn: lambdaExecutionRoleArn,
lambdaClient: this.clients.Lambda,
name: this.names.LAMBDA_FUNCTION,
layerVersionArn,
});
this.cleanUpFunctions.push(lambdaCleanUp);
await this.logger.log(
MESSAGES.functionCreated.replace(
"${FUNCTION_NAME}",
this.names.LAMBDA_FUNCTION,
),
);
this.logger.logSeparator();
await this.logger.log(
MESSAGES.creatingSQSQueue.replace("${QUEUE_NAME}", this.names.SQS_QUEUE),
);
// Create an SQS queue for the SageMaker pipeline.
const {
queueUrl,
queueArn,
cleanUp: queueCleanUp,
} = await createSQSQueue({
name: this.names.SQS_QUEUE,
sqsClient: this.clients.SQS,
});
this.cleanUpFunctions.push(queueCleanUp);
await this.logger.log(
MESSAGES.sqsQueueCreated.replace("${QUEUE_NAME}", this.names.SQS_QUEUE),
);
this.logger.logSeparator();
await this.logger.log(
MESSAGES.configuringLambdaSQSEventSource
.replace("${LAMBDA_NAME}", this.names.LAMBDA_FUNCTION)
.replace("${QUEUE_NAME}", this.names.SQS_QUEUE),
);
// Configure the SQS queue as an event source for the Lambda.
const { cleanUp: lambdaSQSEventSourceCleanUp } =
await configureLambdaSQSEventSource({
lambdaArn,
lambdaName: this.names.LAMBDA_FUNCTION,
queueArn,
sqsClient: this.clients.SQS,
lambdaClient: this.clients.Lambda,
});
this.cleanUpFunctions.push(lambdaSQSEventSourceCleanUp);
await this.logger.log(
MESSAGES.lambdaSQSEventSourceConfigured
.replace("${LAMBDA_NAME}", this.names.LAMBDA_FUNCTION)
.replace("${QUEUE_NAME}", this.names.SQS_QUEUE),
);
this.logger.logSeparator();
// Create an IAM policy that allows the SageMaker pipeline to invoke AWS Lambda
// and send messages to the Amazon SQS queue.
const {
arn: pipelineExecutionPolicyArn,
policy: sagemakerPolicy,
cleanUp: pipelineExecutionPolicyCleanUp,
} = await createSagemakerExecutionPolicy({
sqsQueueArn: queueArn,
lambdaArn,
iamClient: this.clients.IAM,
name: this.names.SAGE_MAKER_EXECUTION_ROLE_POLICY,
s3BucketName: this.names.S3_BUCKET,
});
this.cleanUpFunctions.push(pipelineExecutionPolicyCleanUp);
console.log(JSON.stringify(sagemakerPolicy, null, 2));
await this.logger.log(
MESSAGES.attachPolicy
.replace("${POLICY_NAME}", this.names.SAGE_MAKER_EXECUTION_ROLE_POLICY)
.replace("${ROLE_NAME}", this.names.SAGE_MAKER_EXECUTION_ROLE),
);
await this.prompter.checkContinue();
// Attach the SageMaker execution policy to the execution role.
const { cleanUp: pipelineExecutionRolePolicyCleanUp } = await attachPolicy({
roleName: this.names.SAGE_MAKER_EXECUTION_ROLE,
policyArn: pipelineExecutionPolicyArn,
iamClient: this.clients.IAM,
});
this.cleanUpFunctions.push(pipelineExecutionRolePolicyCleanUp);
// Wait for the role to be ready. If the role is used immediately,
// the pipeline will fail.
await wait(5);
await this.logger.log(MESSAGES.policyAttached);
this.logger.logSeparator();
await this.logger.log(
MESSAGES.creatingPipeline.replace(
"${PIPELINE_NAME}",
this.names.SAGE_MAKER_PIPELINE,
),
);
// Create the SageMaker pipeline.
const { cleanUp: pipelineCleanUp } = await createSagemakerPipeline({
roleArn: pipelineExecutionRoleArn,
functionArn: lambdaArn,
sagemakerClient: this.clients.SageMaker,
name: this.names.SAGE_MAKER_PIPELINE,
});
this.cleanUpFunctions.push(pipelineCleanUp);
await this.logger.log(
MESSAGES.pipelineCreated.replace(
"${PIPELINE_NAME}",
this.names.SAGE_MAKER_PIPELINE,
),
);
this.logger.logSeparator();
await this.logger.log(
MESSAGES.creatingS3Bucket.replace("${BUCKET_NAME}", this.names.S3_BUCKET),
);
// Create an S3 bucket for storing inputs and outputs.
const { cleanUp: s3BucketCleanUp } = await createS3Bucket({
name: this.names.S3_BUCKET,
s3Client: this.clients.S3,
});
this.cleanUpFunctions.push(s3BucketCleanUp);
await this.logger.log(
MESSAGES.s3BucketCreated.replace("${BUCKET_NAME}", this.names.S3_BUCKET),
);
this.logger.logSeparator();
await this.logger.log(
MESSAGES.uploadingInputData.replace(
"${BUCKET_NAME}",
this.names.S3_BUCKET,
),
);
// Upload CSV Lat/Long data to S3.
await uploadCSVDataToS3({
bucketName: this.names.S3_BUCKET,
s3Client: this.clients.S3,
});
await this.logger.log(MESSAGES.inputDataUploaded);
this.logger.logSeparator();
await this.prompter.checkContinue(MESSAGES.executePipeline);
// Execute the SageMaker pipeline.
const { arn: pipelineExecutionArn } = await startPipelineExecution({
name: this.names.SAGE_MAKER_PIPELINE,
sagemakerClient: this.clients.SageMaker,
roleArn: pipelineExecutionRoleArn,
bucketName: this.names.S3_BUCKET,
queueUrl,
});
// Wait for the pipeline execution to finish.
await waitForPipelineComplete({
arn: pipelineExecutionArn,
sagemakerClient: this.clients.SageMaker,
wait,
});
this.logger.logSeparator();
await this.logger.log(MESSAGES.outputDelay);
// The getOutput function will throw an error if the output is not
// found. The retry function will retry a failed function call once
// ever 10 seconds for 2 minutes.
const output = await retry({ intervalInMs: 10000, maxRetries: 12 }, () =>
getObject({
bucket: this.names.S3_BUCKET,
s3Client: this.clients.S3,
}),
);
this.logger.logSeparator();
await this.logger.log(MESSAGES.outputDataRetrieved);
console.log(output.split("\n").slice(0, 6).join("\n"));
}
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para JavaScript *.
+ [CreatePipeline](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sagemaker/command/CreatePipelineCommand)
+ [DeletePipeline](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sagemaker/command/DeletePipelineCommand)
+ [DescribePipelineExecution](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sagemaker/command/DescribePipelineExecutionCommand)
+ [StartPipelineExecution](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sagemaker/command/StartPipelineExecutionCommand)
+ [UpdatePipeline](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sagemaker/command/UpdatePipelineCommand)
# Ejemplos de Secrets Manager con el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante la versión AWS SDK para JavaScript 3 con Secrets Manager.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Acciones](#actions)
## Acciones
### `GetSecretValue`
En el siguiente ejemplo de código, se muestra cómo utilizar `GetSecretValue`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/secrets-manager#code-examples).
```
import {
GetSecretValueCommand,
SecretsManagerClient,
} from "@aws-sdk/client-secrets-manager";
export const getSecretValue = async (secretName = "SECRET_NAME") => {
const client = new SecretsManagerClient();
const response = await client.send(
new GetSecretValueCommand({
SecretId: secretName,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '584eb612-f8b0-48c9-855e-6d246461b604',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// ARN: 'arn:aws:secretsmanager:us-east-1:xxxxxxxxxxxx:secret:binary-secret-3873048-xxxxxx',
// CreatedDate: 2023-08-08T19:29:51.294Z,
// Name: 'binary-secret-3873048',
// SecretBinary: Uint8Array(11) [
// 98, 105, 110, 97, 114,
// 121, 32, 100, 97, 116,
// 97
// ],
// VersionId: '712083f4-0d26-415e-8044-16735142cd6a',
// VersionStages: [ 'AWSCURRENT' ]
// }
if (response.SecretString) {
return response.SecretString;
}
if (response.SecretBinary) {
return response.SecretBinary;
}
};
```
+ Para obtener más información sobre la API, consulta [GetSecretValue](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/secrets-manager/command/GetSecretValueCommand)la *Referencia AWS SDK para JavaScript de la API*.
# Ejemplos de Amazon SES que utilizan el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de la AWS SDK para JavaScript (v3) con Amazon SES.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
Los *escenarios* son ejemplos de código que muestran cómo llevar a cabo una tarea específica a través de llamadas a varias funciones dentro del servicio o combinado con otros Servicios de AWS.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Acciones](#actions)
+ [Escenarios](#scenarios)
## Acciones
### `CreateReceiptFilter`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateReceiptFilter`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import {
CreateReceiptFilterCommand,
ReceiptFilterPolicy,
} from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
const createCreateReceiptFilterCommand = ({ policy, ipOrRange, name }) => {
return new CreateReceiptFilterCommand({
Filter: {
IpFilter: {
Cidr: ipOrRange, // string, either a single IP address (10.0.0.1) or an IP address range in CIDR notation (10.0.0.1/24)).
Policy: policy, // enum ReceiptFilterPolicy, email traffic from the filtered addressesOptions.
},
/*
The name of the IP address filter. Only ASCII letters, numbers, underscores, or dashes.
Must be less than 64 characters and start and end with a letter or number.
*/
Name: name,
},
});
};
const FILTER_NAME = getUniqueName("ReceiptFilter");
const run = async () => {
const createReceiptFilterCommand = createCreateReceiptFilterCommand({
policy: ReceiptFilterPolicy.Allow,
ipOrRange: "10.0.0.1",
name: FILTER_NAME,
});
try {
return await sesClient.send(createReceiptFilterCommand);
} catch (caught) {
if (caught instanceof Error && caught.name === "MessageRejected") {
/** @type { import('@aws-sdk/client-ses').MessageRejected} */
const messageRejectedError = caught;
return messageRejectedError;
}
throw caught;
}
};
```
+ Para obtener más información sobre la API, consulta [CreateReceiptFilter](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/CreateReceiptFilterCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateReceiptRule`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateReceiptRule`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { CreateReceiptRuleCommand, TlsPolicy } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
const RULE_SET_NAME = getUniqueName("RuleSetName");
const RULE_NAME = getUniqueName("RuleName");
const S3_BUCKET_NAME = getUniqueName("S3BucketName");
const createS3ReceiptRuleCommand = ({
bucketName,
emailAddresses,
name,
ruleSet,
}) => {
return new CreateReceiptRuleCommand({
Rule: {
Actions: [
{
S3Action: {
BucketName: bucketName,
ObjectKeyPrefix: "email",
},
},
],
Recipients: emailAddresses,
Enabled: true,
Name: name,
ScanEnabled: false,
TlsPolicy: TlsPolicy.Optional,
},
RuleSetName: ruleSet, // Required
});
};
const run = async () => {
const s3ReceiptRuleCommand = createS3ReceiptRuleCommand({
bucketName: S3_BUCKET_NAME,
emailAddresses: ["email@example.com"],
name: RULE_NAME,
ruleSet: RULE_SET_NAME,
});
try {
return await sesClient.send(s3ReceiptRuleCommand);
} catch (err) {
console.log("Failed to create S3 receipt rule.", err);
throw err;
}
};
```
+ Para obtener más información sobre la API, consulta [CreateReceiptRule](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/CreateReceiptRuleCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateReceiptRuleSet`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateReceiptRuleSet`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { CreateReceiptRuleSetCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
const RULE_SET_NAME = getUniqueName("RuleSetName");
const createCreateReceiptRuleSetCommand = (ruleSetName) => {
return new CreateReceiptRuleSetCommand({ RuleSetName: ruleSetName });
};
const run = async () => {
const createReceiptRuleSetCommand =
createCreateReceiptRuleSetCommand(RULE_SET_NAME);
try {
return await sesClient.send(createReceiptRuleSetCommand);
} catch (err) {
console.log("Failed to create receipt rule set", err);
return err;
}
};
```
+ Para obtener más información sobre la API, consulta [CreateReceiptRuleSet](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/CreateReceiptRuleSetCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateTemplate`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateTemplate`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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: `
Hello, {{contact.firstName}}!
Did you know Amazon has a mascot named Peccy?
`,
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 obtener más información sobre la API, consulta [CreateTemplate](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/CreateTemplateCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteIdentity`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteIdentity`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 obtener más información sobre la API, consulta [DeleteIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/DeleteIdentityCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteReceiptFilter`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteReceiptFilter`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { DeleteReceiptFilterCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
const RECEIPT_FILTER_NAME = getUniqueName("ReceiptFilterName");
const createDeleteReceiptFilterCommand = (filterName) => {
return new DeleteReceiptFilterCommand({ FilterName: filterName });
};
const run = async () => {
const deleteReceiptFilterCommand =
createDeleteReceiptFilterCommand(RECEIPT_FILTER_NAME);
try {
return await sesClient.send(deleteReceiptFilterCommand);
} catch (err) {
console.log("Error deleting receipt filter.", err);
return err;
}
};
```
+ Para obtener más información sobre la API, consulta [DeleteReceiptFilter](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/DeleteReceiptFilterCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteReceiptRule`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteReceiptRule`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { DeleteReceiptRuleCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
const RULE_NAME = getUniqueName("RuleName");
const RULE_SET_NAME = getUniqueName("RuleSetName");
const createDeleteReceiptRuleCommand = () => {
return new DeleteReceiptRuleCommand({
RuleName: RULE_NAME,
RuleSetName: RULE_SET_NAME,
});
};
const run = async () => {
const deleteReceiptRuleCommand = createDeleteReceiptRuleCommand();
try {
return await sesClient.send(deleteReceiptRuleCommand);
} catch (err) {
console.log("Failed to delete receipt rule.", err);
return err;
}
};
```
+ Para obtener más información sobre la API, consulta [DeleteReceiptRule](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/DeleteReceiptRuleCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteReceiptRuleSet`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteReceiptRuleSet`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { DeleteReceiptRuleSetCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";
const RULE_SET_NAME = getUniqueName("RuleSetName");
const createDeleteReceiptRuleSetCommand = () => {
return new DeleteReceiptRuleSetCommand({ RuleSetName: RULE_SET_NAME });
};
const run = async () => {
const deleteReceiptRuleSetCommand = createDeleteReceiptRuleSetCommand();
try {
return await sesClient.send(deleteReceiptRuleSetCommand);
} catch (err) {
console.log("Failed to delete receipt rule set.", err);
return err;
}
};
```
+ Para obtener más información sobre la API, consulta [DeleteReceiptRuleSet](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/DeleteReceiptRuleSetCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteTemplate`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteTemplate`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 obtener más información sobre la API, consulta [DeleteTemplate](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/DeleteTemplateCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `GetTemplate`
En el siguiente ejemplo de código, se muestra cómo utilizar `GetTemplate`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 obtener más información sobre la API, consulta [GetTemplate](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/GetTemplateCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListIdentities`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListIdentities`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 obtener más información sobre la API, consulta [ListIdentities](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/ListIdentitiesCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListReceiptFilters`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListReceiptFilters`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
import { ListReceiptFiltersCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
const createListReceiptFiltersCommand = () => new ListReceiptFiltersCommand({});
const run = async () => {
const listReceiptFiltersCommand = createListReceiptFiltersCommand();
return await sesClient.send(listReceiptFiltersCommand);
};
```
+ Para obtener más información sobre la API, consulta [ListReceiptFilters](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/ListReceiptFiltersCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListTemplates`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListTemplates`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 obtener más información sobre la API, consulta [ListTemplates](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/ListTemplatesCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `SendBulkTemplatedEmail`
En el siguiente ejemplo de código, se muestra cómo utilizar `SendBulkTemplatedEmail`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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: Hello {{name}},
Don't forget about the party gifts!
* Destination 1: Hello Bilbo,
Don't forget about the party gifts!
* Destination 2: Hello Frodo,
Don't forget about the party gifts!
*/
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 obtener más información sobre la API, consulta [SendBulkTemplatedEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendBulkTemplatedEmailCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `SendEmail`
En el siguiente ejemplo de código, se muestra cómo utilizar `SendEmail`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 obtener más información sobre la API, consulta [SendEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendEmailCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `SendRawEmail`
En el siguiente ejemplo de código, se muestra cómo utilizar `SendRawEmail`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
Utilice [nodemailer](https://nodemailer.com/transports/ses) para enviar un correo electrónico con un archivo adjunto.
```
import sesClientModule from "@aws-sdk/client-ses";
/**
* nodemailer wraps the SES SDK and calls SendRawEmail. Use this for more advanced
* functionality like adding attachments to your email.
*
* https://nodemailer.com/transports/ses
*/
import nodemailer from "nodemailer";
/**
* @param {string} from An Amazon SES verified email address.
* @param {*} to An Amazon SES verified email address.
*/
export const sendEmailWithAttachments = (
from = "from@example.com",
to = "to@example.com",
) => {
const ses = new sesClientModule.SESClient({});
const transporter = nodemailer.createTransport({
SES: { ses, aws: sesClientModule },
});
return new Promise((resolve, reject) => {
transporter.sendMail(
{
from,
to,
subject: "Hello World",
text: "Greetings from Amazon SES!",
attachments: [{ content: "Hello World!", filename: "hello.txt" }],
},
(err, info) => {
if (err) {
reject(err);
} else {
resolve(info);
}
},
);
});
};
```
+ Para obtener más información sobre la API, consulta [SendRawEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendRawEmailCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `SendTemplatedEmail`
En el siguiente ejemplo de código, se muestra cómo utilizar `SendTemplatedEmail`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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: Hello {{contact.firstName}},
Don't forget about the party gifts!
* Destination: Hello Bilbo,
Don't forget about the party gifts!
*/
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 obtener más información sobre la API, consulta [SendTemplatedEmail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/SendTemplatedEmailCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `UpdateTemplate`
En el siguiente ejemplo de código, se muestra cómo utilizar `UpdateTemplate`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 = "Hello, World!
";
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 obtener más información sobre la API, consulta [UpdateTemplate](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/UpdateTemplateCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `VerifyDomainIdentity`
En el siguiente ejemplo de código, se muestra cómo utilizar `VerifyDomainIdentity`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
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 obtener más información sobre la API, consulta [VerifyDomainIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyDomainIdentityCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `VerifyEmailIdentity`
En el siguiente ejemplo de código, se muestra cómo utilizar `VerifyEmailIdentity`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses#code-examples).
```
// 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 obtener más información sobre la API, consulta [VerifyEmailIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ses/command/VerifyEmailIdentityCommand)la *Referencia AWS SDK para JavaScript de la API*.
## Escenarios
### Creación de una aplicación de streaming de Amazon Transcribe
El siguiente ejemplo de código muestra cómo crear una aplicación que grabe, transcriba y traduzca audio en directo en tiempo real para luego enviar por correo electrónico los resultados.
**SDK para JavaScript (v3)**
Muestra cómo utilizar Amazon Transcribe para crear una aplicación que grabe, transcriba y traduzca audio en directo en tiempo real para luego enviar los resultados por correo electrónico mediante Amazon Simple Email Service (Amazon SES).
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/transcribe-streaming-app).
**Servicios utilizados en este ejemplo**
+ Amazon Comprehend
+ Amazon SES
+ Amazon Transcribe
+ Amazon Translate
### Crear un rastreador de elementos de trabajo de Aurora Serverless
El siguiente ejemplos de código muestra cómo crear una aplicación web que realice un seguimiento de los elementos de trabajo de una base de datos de Amazon Aurora sin servidor y use Amazon Simple Email Service (Amazon SES) para enviar informes.
**SDK para JavaScript (v3)**
Muestra cómo usar la AWS SDK para JavaScript (v3) para crear una aplicación web que rastrea los elementos de trabajo en una base de datos de Amazon Aurora y envía informes por correo electrónico mediante Amazon Simple Email Service (Amazon SES). Este ejemplo usa un frontend creado con React.js para interactuar con un backend de Node.js de Express.
+ Integre una aplicación web React.js con Servicios de AWS.
+ Cree una lista, agregue y actualice elementos en una tabla de Aurora.
+ Envíe un informe por correo electrónico de elementos de trabajo filtrados con Amazon SES.
+ Implemente y gestione recursos de ejemplo con el AWS CloudFormation script incluido.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app).
**Servicios utilizados en este ejemplo**
+ Aurora
+ Amazon RDS
+ Servicio de datos de Amazon RDS
+ Amazon SES
### Detectar objetos en imágenes
El siguiente ejemplo de código muestra cómo crear una aplicación que utilice Amazon Rekognition para detectar objetos por categoría en imágenes.
**SDK para JavaScript (v3)**
Muestra cómo utilizar Amazon Rekognition AWS SDK para JavaScript con el para crear una aplicación que utilice Amazon Rekognition para identificar objetos por categoría en imágenes ubicadas en un bucket de Amazon Simple Storage Service (Amazon S3). La aplicación envía al administrador una notificación por correo electrónico con los resultados mediante Amazon Simple Email Service (Amazon SES).
Aprenda cómo:
+ Crear un usuario no autenticado con Amazon Cognito.
+ Analizar imágenes en busca de objetos con Amazon Rekognition.
+ Verificar una dirección de correo electrónico de Amazon SES.
+ Enviar una notificación por correo electrónico con Amazon SES.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/photo_analyzer)
**Servicios utilizados en este ejemplo**
+ Amazon Rekognition
+ Amazon S3
+ Amazon SES
# Ejemplos de Amazon SNS con el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de AWS SDK para JavaScript (v3) con Amazon SNS.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
Los *escenarios* son ejemplos de código que muestran cómo llevar a cabo una tarea específica a través de llamadas a varias funciones dentro del servicio o combinado con otros Servicios de AWS.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Introducción](#get_started)
+ [Acciones](#actions)
+ [Escenarios](#scenarios)
+ [Ejemplos de tecnología sin servidor](#serverless_examples)
## Introducción
### Hola Amazon SNS
El siguiente ejemplo de código muestra cómo empezar a utilizar Amazon SNS.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Inicialice un cliente de SNS y muestre los temas de la cuenta.
```
import { SNSClient, paginateListTopics } from "@aws-sdk/client-sns";
export const helloSns = async () => {
// The configuration object (`{}`) is required. If the region and credentials
// are omitted, the SDK uses your local configuration if it exists.
const client = new SNSClient({});
// You can also use `ListTopicsCommand`, but to use that command you must
// handle the pagination yourself. You can do that by sending the `ListTopicsCommand`
// with the `NextToken` parameter from the previous request.
const paginatedTopics = paginateListTopics({ client }, {});
const topics = [];
for await (const page of paginatedTopics) {
if (page.Topics?.length) {
topics.push(...page.Topics);
}
}
const suffix = topics.length === 1 ? "" : "s";
console.log(
`Hello, Amazon SNS! You have ${topics.length} topic${suffix} in your account.`,
);
console.log(topics.map((t) => ` * ${t.TopicArn}`).join("\n"));
};
```
+ Para obtener más información sobre la API, consulta [ListTopics](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/ListTopicsCommand)la *Referencia AWS SDK para JavaScript de la API*.
## Acciones
### `CheckIfPhoneNumberIsOptedOut`
En el siguiente ejemplo de código, se muestra cómo utilizar `CheckIfPhoneNumberIsOptedOut`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-sending-sms.html#sending-sms-checkifphonenumberisoptedout).
+ Para obtener más información sobre la API, consulta [CheckIfPhoneNumberIsOptedOut](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CheckIfPhoneNumberIsOptedOutCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ConfirmSubscription`
En el siguiente ejemplo de código, se muestra cómo utilizar `ConfirmSubscription`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-sending-sms.html#sending-sms-getattributes).
+ Para obtener más información sobre la API, consulta [ConfirmSubscription](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/ConfirmSubscriptionCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateTopic`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateTopic`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-createtopic).
+ Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteTopic`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteTopic`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-deletetopic).
+ Para obtener más información sobre la API, consulta [DeleteTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/DeleteTopicCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `GetSMSAttributes`
En el siguiente ejemplo de código, se muestra cómo utilizar `GetSMSAttributes`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-subscribing-unubscribing-topics.html#sns-confirm-subscription-email).
+ Para obtener más información sobre la API, consulta la *referencia [Get SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/GetSMSAttributesCommand) in AWS SDK para JavaScript API*.
### `GetTopicAttributes`
En el siguiente ejemplo de código, se muestra cómo utilizar `GetTopicAttributes`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topicsgetttopicattributes).
+ Para obtener más información sobre la API, consulta [GetTopicAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/GetTopicAttributesCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListSubscriptions`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListSubscriptions`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topicsgetttopicattributes).
+ Para obtener más información sobre la API, consulta [ListSubscriptions](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/ListSubscriptionsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListTopics`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListTopics`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-listtopics).
+ Para obtener más información sobre la API, consulta [ListTopics](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/ListTopicsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `Publish`
En el siguiente ejemplo de código, se muestra cómo utilizar `Publish`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string | Record} 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;
};
```
Publique un mensaje en un tema con opciones de grupo, duplicación y atributo.
```
async publishMessages() {
const message = await this.prompter.input({
message: MESSAGES.publishMessagePrompt,
});
let groupId;
let deduplicationId;
let choices;
if (this.isFifo) {
await this.logger.log(MESSAGES.groupIdNotice);
groupId = await this.prompter.input({
message: MESSAGES.groupIdPrompt,
});
if (this.autoDedup === false) {
await this.logger.log(MESSAGES.deduplicationIdNotice);
deduplicationId = await this.prompter.input({
message: MESSAGES.deduplicationIdPrompt,
});
}
choices = await this.prompter.checkbox({
message: MESSAGES.messageAttributesPrompt,
choices: toneChoices,
});
}
await this.snsClient.send(
new PublishCommand({
TopicArn: this.topicArn,
Message: message,
...(groupId
? {
MessageGroupId: groupId,
}
: {}),
...(deduplicationId
? {
MessageDeduplicationId: deduplicationId,
}
: {}),
...(choices
? {
MessageAttributes: {
tone: {
DataType: "String.Array",
StringValue: JSON.stringify(choices),
},
},
}
: {}),
}),
);
const publishAnother = await this.prompter.confirm({
message: MESSAGES.publishAnother,
});
if (publishAnother) {
await this.publishMessages();
}
}
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-publishing-messages.html).
+ Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/PublishCommand) en la *Referencia de la API de AWS SDK para JavaScript *.
### `SetSMSAttributes`
En el siguiente ejemplo de código, se muestra cómo utilizar `SetSMSAttributes`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-sending-sms.html#sending-sms-setattributes).
+ Para obtener más información sobre la API, consulta [Establecer SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/SetSMSAttributesCommand) en la *referencia AWS SDK para JavaScript de la API*.
### `SetTopicAttributes`
En el siguiente ejemplo de código, se muestra cómo utilizar `SetTopicAttributes`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topicsstttopicattributes).
+ Para obtener más información sobre la API, consulta [SetTopicAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/SetTopicAttributesCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `Subscribe`
En el siguiente ejemplo de código, se muestra cómo utilizar `Subscribe`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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'
// }
};
```
Suscriba una aplicación móvil a un tema.
```
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;
};
```
Suscriba una función de Lambda a un tema.
```
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;
};
```
Suscriba una cola de SQS a un tema.
```
import { SubscribeCommand, SNSClient } from "@aws-sdk/client-sns";
const client = new SNSClient({});
export const subscribeQueue = async (
topicArn = "TOPIC_ARN",
queueArn = "QUEUE_ARN",
) => {
const command = new SubscribeCommand({
TopicArn: topicArn,
Protocol: "sqs",
Endpoint: queueArn,
});
const response = await client.send(command);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '931e13d9-5e2b-543f-8781-4e9e494c5ff2',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// SubscriptionArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:subscribe-queue-test-430895:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
// }
return response;
};
```
Suscribirse con un filtro a un tema.
```
import { SubscribeCommand, SNSClient } from "@aws-sdk/client-sns";
const client = new SNSClient({});
export const subscribeQueueFiltered = async (
topicArn = "TOPIC_ARN",
queueArn = "QUEUE_ARN",
) => {
const command = new SubscribeCommand({
TopicArn: topicArn,
Protocol: "sqs",
Endpoint: queueArn,
Attributes: {
// This subscription will only receive messages with the 'event' attribute set to 'order_placed'.
FilterPolicyScope: "MessageAttributes",
FilterPolicy: JSON.stringify({
event: ["order_placed"],
}),
},
});
const response = await client.send(command);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '931e13d9-5e2b-543f-8781-4e9e494c5ff2',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// SubscriptionArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:subscribe-queue-test-430895:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
// }
return response;
};
```
+ Para obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-subscribing-email).
+ Para obtener detalles sobre la API, consulte [Subscribe](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/SubscribeCommand) en la *Referencia de la API de AWS SDK para JavaScript *.
### `Unsubscribe`
En el siguiente ejemplo de código, se muestra cómo utilizar `Unsubscribe`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
Cree el cliente en un módulo separado y expórtelo.
```
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({});
```
Importe el SDK y los módulos cliente, y llame a la API.
```
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 obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-unsubscribing).
+ Para obtener detalles sobre la API, consulte [Unsubscribe](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/UnsubscribeCommand) en la *Referencia de la API de AWS SDK para JavaScript *.
## Escenarios
### Creación de una aplicación para enviar datos a una tabla de DynamoDB
El siguiente ejemplo de código muestra cómo crear una aplicación que envíe datos a una tabla de Amazon DynamoDB y que le notifique cuando un usuario actualice la tabla.
**SDK para JavaScript (v3)**
Este ejemplo indica cómo crear una aplicación que permita a los usuarios enviar datos a una tabla de Amazon DynamoDB y un mensaje de texto al administrador mediante Amazon Simple Notification Service (Amazon SNS).
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/submit-data-app).
Este ejemplo también está disponible en la [Guía para desarrolladores de AWS SDK para JavaScript v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/cross-service-example-submitting-data.html).
**Servicios utilizados en este ejemplo**
+ DynamoDB
+ Amazon SNS
### Creación de una aplicación sin servidor para administrar fotos
En el siguiente ejemplo de código se muestra cómo crear una aplicación sin servidor que permita a los usuarios administrar fotos mediante etiquetas.
**SDK para JavaScript (v3)**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/photo-asset-manager).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
### Creación de una aplicación de exploración de Amazon Textract
El siguiente ejemplo de código muestra cómo explorar la salida de Amazon Textract mediante una aplicación interactiva.
**SDK para JavaScript (v3)**
Muestra cómo utilizarla AWS SDK para JavaScript para crear una aplicación de React que utilice Amazon Textract para extraer datos de la imagen de un documento y mostrarlos en una página web interactiva. Este ejemplo se ejecuta en un navegador web y requiere una identidad autenticada de Amazon Cognito para las credenciales. Para el almacenamiento utiliza Amazon Simple Storage Service (Amazon S3) y para las notificaciones consulta una cola de Amazon Simple Queue Service (Amazon SQS) que está suscrita a un tema de Amazon Simple Notification Service (Amazon SNS).
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/textract-react).
**Servicios utilizados en este ejemplo**
+ Amazon Cognito Identity
+ Amazon S3
+ Amazon SNS
+ Amazon SQS
+ Amazon Textract
### Publicación de mensajes en colas
En el siguiente ejemplo de código, se muestra cómo:
+ Crear un tema (FIFO o no FIFO)
+ Suscribir varias colas al tema con la opción de aplicar un filtro
+ Publicar mensajes en el tema
+ Sondear las colas en busca de los mensajes recibidos
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/wkflw-topics-queues#code-examples).
Este es el punto de entrada de este escenario.
```
import { SNSClient } from "@aws-sdk/client-sns";
import { SQSClient } from "@aws-sdk/client-sqs";
import { TopicsQueuesWkflw } from "./TopicsQueuesWkflw.js";
import { Prompter } from "@aws-doc-sdk-examples/lib/prompter.js";
export const startSnsWorkflow = () => {
const snsClient = new SNSClient({});
const sqsClient = new SQSClient({});
const prompter = new Prompter();
const logger = console;
const wkflw = new TopicsQueuesWkflw(snsClient, sqsClient, prompter, logger);
wkflw.start();
};
```
El código anterior proporciona las dependencias necesarias e inicia el escenario. La siguiente sección contiene la mayor parte del ejemplo.
```
const toneChoices = [
{ name: "cheerful", value: "cheerful" },
{ name: "funny", value: "funny" },
{ name: "serious", value: "serious" },
{ name: "sincere", value: "sincere" },
];
export class TopicsQueuesWkflw {
// SNS topic is configured as First-In-First-Out
isFifo = true;
// Automatic content-based deduplication is enabled.
autoDedup = false;
snsClient;
sqsClient;
topicName;
topicArn;
subscriptionArns = [];
/**
* @type {{ queueName: string, queueArn: string, queueUrl: string, policy?: string }[]}
*/
queues = [];
prompter;
/**
* @param {import('@aws-sdk/client-sns').SNSClient} snsClient
* @param {import('@aws-sdk/client-sqs').SQSClient} sqsClient
* @param {import('../../libs/prompter.js').Prompter} prompter
* @param {import('../../libs/logger.js').Logger} logger
*/
constructor(snsClient, sqsClient, prompter, logger) {
this.snsClient = snsClient;
this.sqsClient = sqsClient;
this.prompter = prompter;
this.logger = logger;
}
async welcome() {
await this.logger.log(MESSAGES.description);
}
async confirmFifo() {
await this.logger.log(MESSAGES.snsFifoDescription);
this.isFifo = await this.prompter.confirm({
message: MESSAGES.snsFifoPrompt,
});
if (this.isFifo) {
this.logger.logSeparator(MESSAGES.headerDedup);
await this.logger.log(MESSAGES.deduplicationNotice);
await this.logger.log(MESSAGES.deduplicationDescription);
this.autoDedup = await this.prompter.confirm({
message: MESSAGES.deduplicationPrompt,
});
}
}
async createTopic() {
await this.logger.log(MESSAGES.creatingTopics);
this.topicName = await this.prompter.input({
message: MESSAGES.topicNamePrompt,
});
if (this.isFifo) {
this.topicName += ".fifo";
this.logger.logSeparator(MESSAGES.headerFifoNaming);
await this.logger.log(MESSAGES.appendFifoNotice);
}
const response = await this.snsClient.send(
new CreateTopicCommand({
Name: this.topicName,
Attributes: {
FifoTopic: this.isFifo ? "true" : "false",
...(this.autoDedup ? { ContentBasedDeduplication: "true" } : {}),
},
}),
);
this.topicArn = response.TopicArn;
await this.logger.log(
MESSAGES.topicCreatedNotice
.replace("${TOPIC_NAME}", this.topicName)
.replace("${TOPIC_ARN}", this.topicArn),
);
}
async createQueues() {
await this.logger.log(MESSAGES.createQueuesNotice);
// Increase this number to add more queues.
const maxQueues = 2;
for (let i = 0; i < maxQueues; i++) {
await this.logger.log(MESSAGES.queueCount.replace("${COUNT}", i + 1));
let queueName = await this.prompter.input({
message: MESSAGES.queueNamePrompt.replace(
"${EXAMPLE_NAME}",
i === 0 ? "good-news" : "bad-news",
),
});
if (this.isFifo) {
queueName += ".fifo";
await this.logger.log(MESSAGES.appendFifoNotice);
}
const response = await this.sqsClient.send(
new CreateQueueCommand({
QueueName: queueName,
Attributes: { ...(this.isFifo ? { FifoQueue: "true" } : {}) },
}),
);
const { Attributes } = await this.sqsClient.send(
new GetQueueAttributesCommand({
QueueUrl: response.QueueUrl,
AttributeNames: ["QueueArn"],
}),
);
this.queues.push({
queueName,
queueArn: Attributes.QueueArn,
queueUrl: response.QueueUrl,
});
await this.logger.log(
MESSAGES.queueCreatedNotice
.replace("${QUEUE_NAME}", queueName)
.replace("${QUEUE_URL}", response.QueueUrl)
.replace("${QUEUE_ARN}", Attributes.QueueArn),
);
}
}
async attachQueueIamPolicies() {
for (const [index, queue] of this.queues.entries()) {
const policy = JSON.stringify(
{
Statement: [
{
Effect: "Allow",
Principal: {
Service: "sns.amazonaws.com",
},
Action: "sqs:SendMessage",
Resource: queue.queueArn,
Condition: {
ArnEquals: {
"aws:SourceArn": this.topicArn,
},
},
},
],
},
null,
2,
);
if (index !== 0) {
this.logger.logSeparator();
}
await this.logger.log(MESSAGES.attachPolicyNotice);
console.log(policy);
const addPolicy = await this.prompter.confirm({
message: MESSAGES.addPolicyConfirmation.replace(
"${QUEUE_NAME}",
queue.queueName,
),
});
if (addPolicy) {
await this.sqsClient.send(
new SetQueueAttributesCommand({
QueueUrl: queue.queueUrl,
Attributes: {
Policy: policy,
},
}),
);
queue.policy = policy;
} else {
await this.logger.log(
MESSAGES.policyNotAttachedNotice.replace(
"${QUEUE_NAME}",
queue.queueName,
),
);
}
}
}
async subscribeQueuesToTopic() {
for (const [index, queue] of this.queues.entries()) {
/**
* @type {import('@aws-sdk/client-sns').SubscribeCommandInput}
*/
const subscribeParams = {
TopicArn: this.topicArn,
Protocol: "sqs",
Endpoint: queue.queueArn,
};
let tones = [];
if (this.isFifo) {
if (index === 0) {
await this.logger.log(MESSAGES.fifoFilterNotice);
}
tones = await this.prompter.checkbox({
message: MESSAGES.fifoFilterSelect.replace(
"${QUEUE_NAME}",
queue.queueName,
),
choices: toneChoices,
});
if (tones.length) {
subscribeParams.Attributes = {
FilterPolicyScope: "MessageAttributes",
FilterPolicy: JSON.stringify({
tone: tones,
}),
};
}
}
const { SubscriptionArn } = await this.snsClient.send(
new SubscribeCommand(subscribeParams),
);
this.subscriptionArns.push(SubscriptionArn);
await this.logger.log(
MESSAGES.queueSubscribedNotice
.replace("${QUEUE_NAME}", queue.queueName)
.replace("${TOPIC_NAME}", this.topicName)
.replace("${TONES}", tones.length ? tones.join(", ") : "none"),
);
}
}
async publishMessages() {
const message = await this.prompter.input({
message: MESSAGES.publishMessagePrompt,
});
let groupId;
let deduplicationId;
let choices;
if (this.isFifo) {
await this.logger.log(MESSAGES.groupIdNotice);
groupId = await this.prompter.input({
message: MESSAGES.groupIdPrompt,
});
if (this.autoDedup === false) {
await this.logger.log(MESSAGES.deduplicationIdNotice);
deduplicationId = await this.prompter.input({
message: MESSAGES.deduplicationIdPrompt,
});
}
choices = await this.prompter.checkbox({
message: MESSAGES.messageAttributesPrompt,
choices: toneChoices,
});
}
await this.snsClient.send(
new PublishCommand({
TopicArn: this.topicArn,
Message: message,
...(groupId
? {
MessageGroupId: groupId,
}
: {}),
...(deduplicationId
? {
MessageDeduplicationId: deduplicationId,
}
: {}),
...(choices
? {
MessageAttributes: {
tone: {
DataType: "String.Array",
StringValue: JSON.stringify(choices),
},
},
}
: {}),
}),
);
const publishAnother = await this.prompter.confirm({
message: MESSAGES.publishAnother,
});
if (publishAnother) {
await this.publishMessages();
}
}
async receiveAndDeleteMessages() {
for (const queue of this.queues) {
const { Messages } = await this.sqsClient.send(
new ReceiveMessageCommand({
QueueUrl: queue.queueUrl,
}),
);
if (Messages) {
await this.logger.log(
MESSAGES.messagesReceivedNotice.replace(
"${QUEUE_NAME}",
queue.queueName,
),
);
console.log(Messages);
await this.sqsClient.send(
new DeleteMessageBatchCommand({
QueueUrl: queue.queueUrl,
Entries: Messages.map((message) => ({
Id: message.MessageId,
ReceiptHandle: message.ReceiptHandle,
})),
}),
);
} else {
await this.logger.log(
MESSAGES.noMessagesReceivedNotice.replace(
"${QUEUE_NAME}",
queue.queueName,
),
);
}
}
const deleteAndPoll = await this.prompter.confirm({
message: MESSAGES.deleteAndPollConfirmation,
});
if (deleteAndPoll) {
await this.receiveAndDeleteMessages();
}
}
async destroyResources() {
for (const subscriptionArn of this.subscriptionArns) {
await this.snsClient.send(
new UnsubscribeCommand({ SubscriptionArn: subscriptionArn }),
);
}
for (const queue of this.queues) {
await this.sqsClient.send(
new DeleteQueueCommand({ QueueUrl: queue.queueUrl }),
);
}
if (this.topicArn) {
await this.snsClient.send(
new DeleteTopicCommand({ TopicArn: this.topicArn }),
);
}
}
async start() {
console.clear();
try {
this.logger.logSeparator(MESSAGES.headerWelcome);
await this.welcome();
this.logger.logSeparator(MESSAGES.headerFifo);
await this.confirmFifo();
this.logger.logSeparator(MESSAGES.headerCreateTopic);
await this.createTopic();
this.logger.logSeparator(MESSAGES.headerCreateQueues);
await this.createQueues();
this.logger.logSeparator(MESSAGES.headerAttachPolicy);
await this.attachQueueIamPolicies();
this.logger.logSeparator(MESSAGES.headerSubscribeQueues);
await this.subscribeQueuesToTopic();
this.logger.logSeparator(MESSAGES.headerPublishMessage);
await this.publishMessages();
this.logger.logSeparator(MESSAGES.headerReceiveMessages);
await this.receiveAndDeleteMessages();
} catch (err) {
console.error(err);
} finally {
await this.destroyResources();
}
}
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para JavaScript *.
+ [CreateQueue](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/CreateQueueCommand)
+ [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)
+ [DeleteMessageBatch](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/DeleteMessageBatchCommand)
+ [DeleteQueue](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/DeleteQueueCommand)
+ [DeleteTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/DeleteTopicCommand)
+ [GetQueueAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/GetQueueAttributesCommand)
+ [Publish](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/PublishCommand)
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/ReceiveMessageCommand)
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/SetQueueAttributesCommand)
+ [Subscribe](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/SubscribeCommand)
+ [Unsubscribe](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/UnsubscribeCommand)
### Uso de API Gateway para invocar una función de Lambda
El siguiente ejemplo de código muestra cómo crear una AWS Lambda función invocada por Amazon API Gateway.
**SDK para JavaScript (v3)**
Muestra cómo crear una AWS Lambda función mediante la API de tiempo de JavaScript ejecución de Lambda. En este ejemplo, se invocan diferentes AWS servicios para realizar un caso de uso específico. En este ejemplo se indica cómo crear una función de Lambda invocada por Amazon API Gateway que escanea una tabla de Amazon DynamoDB en busca de aniversarios laborales y utiliza Amazon Simple Notification Service (Amazon SNS) para enviar un mensaje de texto a sus empleados que les felicite en la fecha de su primer aniversario.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway).
Este ejemplo también está disponible en la [Guía para desarrolladores de AWS SDK para JavaScript v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/api-gateway-invoking-lambda-example.html).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon SNS
### Uso de eventos programados para invocar una función de Lambda
El siguiente ejemplo de código muestra cómo crear una AWS Lambda función invocada por un evento EventBridge programado de Amazon.
**SDK para JavaScript (v3)**
Muestra cómo crear un evento EventBridge programado de Amazon que invoque una AWS Lambda función. Configure EventBridge para usar una expresión cron para programar cuándo se invoca la función Lambda. En este ejemplo, se crea una función de Lambda mediante la API de tiempo de ejecución de JavaScript Lambda. En este ejemplo, se invocan diferentes AWS servicios para realizar un caso de uso específico. Este ejemplo indica cómo crear una aplicación que envíe un mensaje de texto a sus empleados para felicitarles por su primer aniversario.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-scheduled-events).
Este ejemplo también está disponible en la [Guía para desarrolladores de AWS SDK para JavaScript v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/scheduled-events-invoking-lambda-example.html).
**Servicios utilizados en este ejemplo**
+ CloudWatch Registros
+ DynamoDB
+ EventBridge
+ Lambda
+ Amazon SNS
## Ejemplos de tecnología sin servidor
### Invocación de una función de Lambda desde un desencadenador de Amazon SNS
En el siguiente ejemplo de código se muestra cómo implementar una función de Lambda que recibe un evento activado al recibir mensajes de un tema de SNS. La función recupera los mensajes del parámetro de eventos y registra el contenido de cada mensaje.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/blob/main/integration-sns-to-lambda).
Consumir un evento de SNS con JavaScript Lambda mediante.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
exports.handler = async (event, context) => {
for (const record of event.Records) {
await processMessageAsync(record);
}
console.info("done");
};
async function processMessageAsync(record) {
try {
const message = JSON.stringify(record.Sns.Message);
console.log(`Processed message ${message}`);
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
Consumir un evento de SNS con TypeScript Lambda mediante.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SNSEvent, Context, SNSHandler, SNSEventRecord } from "aws-lambda";
export const functionHandler: SNSHandler = async (
event: SNSEvent,
context: Context
): Promise => {
for (const record of event.Records) {
await processMessageAsync(record);
}
console.info("done");
};
async function processMessageAsync(record: SNSEventRecord): Promise {
try {
const message: string = JSON.stringify(record.Sns.Message);
console.log(`Processed message ${message}`);
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
# Ejemplos de Amazon SQS con el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de AWS SDK para JavaScript (v3) con Amazon SQS.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
Los *escenarios* son ejemplos de código que muestran cómo llevar a cabo una tarea específica a través de llamadas a varias funciones dentro del servicio o combinado con otros Servicios de AWS.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Introducción](#get_started)
+ [Acciones](#actions)
+ [Escenarios](#scenarios)
+ [Ejemplos de tecnología sin servidor](#serverless_examples)
## Introducción
### Introducción a Amazon SQS
El siguiente ejemplo de código muestra cómo empezar a utilizar Amazon SQS.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Inicializar un cliente de Amazon SQS y enumerar las colas.
```
import { SQSClient, paginateListQueues } from "@aws-sdk/client-sqs";
export const helloSqs = async () => {
// The configuration object (`{}`) is required. If the region and credentials
// are omitted, the SDK uses your local configuration if it exists.
const client = new SQSClient({});
// You can also use `ListQueuesCommand`, but to use that command you must
// handle the pagination yourself. You can do that by sending the `ListQueuesCommand`
// with the `NextToken` parameter from the previous request.
const paginatedQueues = paginateListQueues({ client }, {});
const queues = [];
for await (const page of paginatedQueues) {
if (page.QueueUrls?.length) {
queues.push(...page.QueueUrls);
}
}
const suffix = queues.length === 1 ? "" : "s";
console.log(
`Hello, Amazon SQS! You have ${queues.length} queue${suffix} in your account.`,
);
console.log(queues.map((t) => ` * ${t}`).join("\n"));
};
```
+ Para obtener más información sobre la API, consulta [ListQueues](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/ListQueuesCommand)la *Referencia AWS SDK para JavaScript de la API*.
## Acciones
### `ChangeMessageVisibility`
En el siguiente ejemplo de código, se muestra cómo utilizar `ChangeMessageVisibility`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Recibir un mensaje de Amazon SQS y cambiar la visibilidad del tiempo de espera.
```
import {
ReceiveMessageCommand,
ChangeMessageVisibilityCommand,
SQSClient,
} from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
const receiveMessage = (queueUrl) =>
client.send(
new ReceiveMessageCommand({
AttributeNames: ["SentTimestamp"],
MaxNumberOfMessages: 1,
MessageAttributeNames: ["All"],
QueueUrl: queueUrl,
WaitTimeSeconds: 1,
}),
);
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const { Messages } = await receiveMessage(queueUrl);
const response = await client.send(
new ChangeMessageVisibilityCommand({
QueueUrl: queueUrl,
ReceiptHandle: Messages[0].ReceiptHandle,
VisibilityTimeout: 20,
}),
);
console.log(response);
return response;
};
```
+ Para obtener más información sobre la API, consulta [ChangeMessageVisibility](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/ChangeMessageVisibilityCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateQueue`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateQueue`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Crear una cola estándar de Amazon SQS.
```
import { CreateQueueCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_NAME = "test-queue";
export const main = async (sqsQueueName = SQS_QUEUE_NAME) => {
const command = new CreateQueueCommand({
QueueName: sqsQueueName,
Attributes: {
DelaySeconds: "60",
MessageRetentionPeriod: "86400",
},
});
const response = await client.send(command);
console.log(response);
return response;
};
```
Crear una cola de Amazon SQS con sondeo largo.
```
import { CreateQueueCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_NAME = "queue_name";
export const main = async (queueName = SQS_QUEUE_NAME) => {
const response = await client.send(
new CreateQueueCommand({
QueueName: queueName,
Attributes: {
// When the wait time for the ReceiveMessage API action is greater than 0,
// long polling is in effect. The maximum long polling wait time is 20
// seconds. Long polling helps reduce the cost of using Amazon SQS by,
// eliminating the number of empty responses and false empty responses.
// https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-short-and-long-polling.html
ReceiveMessageWaitTimeSeconds: "20",
},
}),
);
console.log(response);
return response;
};
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-using-queues.html#sqs-examples-using-queues-create-queue).
+ Para obtener más información sobre la API, consulta [CreateQueue](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/CreateQueueCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteMessage`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteMessage`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Recibir y eliminar mensajes de Amazon SQS.
```
import {
ReceiveMessageCommand,
DeleteMessageCommand,
SQSClient,
DeleteMessageBatchCommand,
} from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
const receiveMessage = (queueUrl) =>
client.send(
new ReceiveMessageCommand({
AttributeNames: ["SentTimestamp"],
MaxNumberOfMessages: 10,
MessageAttributeNames: ["All"],
QueueUrl: queueUrl,
WaitTimeSeconds: 20,
VisibilityTimeout: 20,
}),
);
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const { Messages } = await receiveMessage(queueUrl);
if (!Messages) {
return;
}
if (Messages.length === 1) {
console.log(Messages[0].Body);
await client.send(
new DeleteMessageCommand({
QueueUrl: queueUrl,
ReceiptHandle: Messages[0].ReceiptHandle,
}),
);
} else {
await client.send(
new DeleteMessageBatchCommand({
QueueUrl: queueUrl,
Entries: Messages.map((message) => ({
Id: message.MessageId,
ReceiptHandle: message.ReceiptHandle,
})),
}),
);
}
};
```
+ Para obtener más información sobre la API, consulta [DeleteMessage](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/DeleteMessageCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteMessageBatch`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteMessageBatch`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
```
import {
ReceiveMessageCommand,
DeleteMessageCommand,
SQSClient,
DeleteMessageBatchCommand,
} from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
const receiveMessage = (queueUrl) =>
client.send(
new ReceiveMessageCommand({
AttributeNames: ["SentTimestamp"],
MaxNumberOfMessages: 10,
MessageAttributeNames: ["All"],
QueueUrl: queueUrl,
WaitTimeSeconds: 20,
VisibilityTimeout: 20,
}),
);
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const { Messages } = await receiveMessage(queueUrl);
if (!Messages) {
return;
}
if (Messages.length === 1) {
console.log(Messages[0].Body);
await client.send(
new DeleteMessageCommand({
QueueUrl: queueUrl,
ReceiptHandle: Messages[0].ReceiptHandle,
}),
);
} else {
await client.send(
new DeleteMessageBatchCommand({
QueueUrl: queueUrl,
Entries: Messages.map((message) => ({
Id: message.MessageId,
ReceiptHandle: message.ReceiptHandle,
})),
}),
);
}
};
```
+ Para obtener más información sobre la API, consulta [DeleteMessageBatch](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/DeleteMessageBatchCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteQueue`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteQueue`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Eliminar una cola de Amazon SQS.
```
import { DeleteQueueCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "test-queue-url";
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const command = new DeleteQueueCommand({ QueueUrl: queueUrl });
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-using-queues.html#sqs-examples-using-queues-delete-queue).
+ Para obtener más información sobre la API, consulta [DeleteQueue](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/DeleteQueueCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `GetQueueAttributes`
En el siguiente ejemplo de código, se muestra cómo utilizar `GetQueueAttributes`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
```
import { GetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue-url";
export const getQueueAttributes = async (queueUrl = SQS_QUEUE_URL) => {
const command = new GetQueueAttributesCommand({
QueueUrl: queueUrl,
AttributeNames: ["DelaySeconds"],
});
const response = await client.send(command);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '747a1192-c334-5682-a508-4cd5e8dc4e79',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// Attributes: { DelaySeconds: '1' }
// }
return response;
};
```
+ Para obtener más información sobre la API, consulta [GetQueueAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/GetQueueAttributesCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `GetQueueUrl`
En el siguiente ejemplo de código, se muestra cómo utilizar `GetQueueUrl`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Obtener la URL de una cola de Amazon SQS.
```
import { GetQueueUrlCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_NAME = "test-queue";
export const main = async (queueName = SQS_QUEUE_NAME) => {
const command = new GetQueueUrlCommand({ QueueName: queueName });
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-using-queues.html#sqs-examples-using-queues-get-queue-url).
+ Para obtener más información sobre la API, consulta [GetQueueUrl](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/GetQueueUrlCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListQueues`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListQueues`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Enumerar las colas de Amazon SQS.
```
import { paginateListQueues, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
export const main = async () => {
const paginatedListQueues = paginateListQueues({ client }, {});
/** @type {string[]} */
const urls = [];
for await (const page of paginatedListQueues) {
const nextUrls = page.QueueUrls?.filter((qurl) => !!qurl) || [];
urls.push(...nextUrls);
for (const url of urls) {
console.log(url);
}
}
return urls;
};
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-using-queues.html#sqs-examples-using-queues-listing-queues).
+ Para obtener más información sobre la API, consulta [ListQueues](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/ListQueuesCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ReceiveMessage`
En el siguiente ejemplo de código, se muestra cómo utilizar `ReceiveMessage`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Recibir un mensaje de una cola de Amazon SQS.
```
import {
ReceiveMessageCommand,
DeleteMessageCommand,
SQSClient,
DeleteMessageBatchCommand,
} from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
const receiveMessage = (queueUrl) =>
client.send(
new ReceiveMessageCommand({
AttributeNames: ["SentTimestamp"],
MaxNumberOfMessages: 10,
MessageAttributeNames: ["All"],
QueueUrl: queueUrl,
WaitTimeSeconds: 20,
VisibilityTimeout: 20,
}),
);
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const { Messages } = await receiveMessage(queueUrl);
if (!Messages) {
return;
}
if (Messages.length === 1) {
console.log(Messages[0].Body);
await client.send(
new DeleteMessageCommand({
QueueUrl: queueUrl,
ReceiptHandle: Messages[0].ReceiptHandle,
}),
);
} else {
await client.send(
new DeleteMessageBatchCommand({
QueueUrl: queueUrl,
Entries: Messages.map((message) => ({
Id: message.MessageId,
ReceiptHandle: message.ReceiptHandle,
})),
}),
);
}
};
```
Recibir un mensaje de una cola de Amazon SQS mediante el soporte de sondeos largos.
```
import { ReceiveMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue-url";
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const command = new ReceiveMessageCommand({
AttributeNames: ["SentTimestamp"],
MaxNumberOfMessages: 1,
MessageAttributeNames: ["All"],
QueueUrl: queueUrl,
// The duration (in seconds) for which the call waits for a message
// to arrive in the queue before returning. If a message is available,
// the call returns sooner than WaitTimeSeconds. If no messages are
// available and the wait time expires, the call returns successfully
// with an empty list of messages.
// https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html#API_ReceiveMessage_RequestSyntax
WaitTimeSeconds: 20,
});
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Para obtener más información sobre la API, consulta [ReceiveMessage](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/ReceiveMessageCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `SendMessage`
En el siguiente ejemplo de código, se muestra cómo utilizar `SendMessage`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Enviar un mensaje a una cola de Amazon SQS.
```
import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
export const main = async (sqsQueueUrl = SQS_QUEUE_URL) => {
const command = new SendMessageCommand({
QueueUrl: sqsQueueUrl,
DelaySeconds: 10,
MessageAttributes: {
Title: {
DataType: "String",
StringValue: "The Whistler",
},
Author: {
DataType: "String",
StringValue: "John Grisham",
},
WeeksOn: {
DataType: "Number",
StringValue: "6",
},
},
MessageBody:
"Information about current NY Times fiction bestseller for week of 12/11/2016.",
});
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-send-receive-messages.html#sqs-examples-send-receive-messages-sending).
+ Para obtener más información sobre la API, consulta [SendMessage](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/SendMessageCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `SetQueueAttributes`
En el siguiente ejemplo de código, se muestra cómo utilizar `SetQueueAttributes`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
```
import { SetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue-url";
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const command = new SetQueueAttributesCommand({
QueueUrl: queueUrl,
Attributes: {
DelaySeconds: "1",
},
});
const response = await client.send(command);
console.log(response);
return response;
};
```
Configurar una cola de Amazon SQS para utilizar sondeos largos.
```
import { SetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const command = new SetQueueAttributesCommand({
Attributes: {
ReceiveMessageWaitTimeSeconds: "20",
},
QueueUrl: queueUrl,
});
const response = await client.send(command);
console.log(response);
return response;
};
```
Configurar una cola de mensajes fallidos.
```
import { SetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
const DEAD_LETTER_QUEUE_ARN = "dead_letter_queue_arn";
export const main = async (
queueUrl = SQS_QUEUE_URL,
deadLetterQueueArn = DEAD_LETTER_QUEUE_ARN,
) => {
const command = new SetQueueAttributesCommand({
Attributes: {
RedrivePolicy: JSON.stringify({
// Amazon SQS supports dead-letter queues (DLQ), which other
// queues (source queues) can target for messages that can't
// be processed (consumed) successfully.
// https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html
deadLetterTargetArn: deadLetterQueueArn,
maxReceiveCount: "10",
}),
},
QueueUrl: queueUrl,
});
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Para obtener más información sobre la API, consulta [SetQueueAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/SetQueueAttributesCommand)la *Referencia AWS SDK para JavaScript de la API*.
## Escenarios
### Creación de una aplicación de exploración de Amazon Textract
El siguiente ejemplo de código muestra cómo explorar la salida de Amazon Textract mediante una aplicación interactiva.
**SDK para JavaScript (v3)**
Muestra cómo utilizarla AWS SDK para JavaScript para crear una aplicación de React que utilice Amazon Textract para extraer datos de la imagen de un documento y mostrarlos en una página web interactiva. Este ejemplo se ejecuta en un navegador web y requiere una identidad autenticada de Amazon Cognito para las credenciales. Para el almacenamiento utiliza Amazon Simple Storage Service (Amazon S3) y para las notificaciones consulta una cola de Amazon Simple Queue Service (Amazon SQS) que está suscrita a un tema de Amazon Simple Notification Service (Amazon SNS).
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/textract-react).
**Servicios utilizados en este ejemplo**
+ Amazon Cognito Identity
+ Amazon S3
+ Amazon SNS
+ Amazon SQS
+ Amazon Textract
### Publicación de mensajes en colas
En el siguiente ejemplo de código, se muestra cómo:
+ Crear un tema (FIFO o no FIFO)
+ Suscribir varias colas al tema con la opción de aplicar un filtro
+ Publicar mensajes en el tema
+ Sondear las colas en busca de los mensajes recibidos
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/wkflw-topics-queues#code-examples).
Este es el punto de entrada de este escenario.
```
import { SNSClient } from "@aws-sdk/client-sns";
import { SQSClient } from "@aws-sdk/client-sqs";
import { TopicsQueuesWkflw } from "./TopicsQueuesWkflw.js";
import { Prompter } from "@aws-doc-sdk-examples/lib/prompter.js";
export const startSnsWorkflow = () => {
const snsClient = new SNSClient({});
const sqsClient = new SQSClient({});
const prompter = new Prompter();
const logger = console;
const wkflw = new TopicsQueuesWkflw(snsClient, sqsClient, prompter, logger);
wkflw.start();
};
```
El código anterior proporciona las dependencias necesarias e inicia el escenario. La siguiente sección contiene la mayor parte del ejemplo.
```
const toneChoices = [
{ name: "cheerful", value: "cheerful" },
{ name: "funny", value: "funny" },
{ name: "serious", value: "serious" },
{ name: "sincere", value: "sincere" },
];
export class TopicsQueuesWkflw {
// SNS topic is configured as First-In-First-Out
isFifo = true;
// Automatic content-based deduplication is enabled.
autoDedup = false;
snsClient;
sqsClient;
topicName;
topicArn;
subscriptionArns = [];
/**
* @type {{ queueName: string, queueArn: string, queueUrl: string, policy?: string }[]}
*/
queues = [];
prompter;
/**
* @param {import('@aws-sdk/client-sns').SNSClient} snsClient
* @param {import('@aws-sdk/client-sqs').SQSClient} sqsClient
* @param {import('../../libs/prompter.js').Prompter} prompter
* @param {import('../../libs/logger.js').Logger} logger
*/
constructor(snsClient, sqsClient, prompter, logger) {
this.snsClient = snsClient;
this.sqsClient = sqsClient;
this.prompter = prompter;
this.logger = logger;
}
async welcome() {
await this.logger.log(MESSAGES.description);
}
async confirmFifo() {
await this.logger.log(MESSAGES.snsFifoDescription);
this.isFifo = await this.prompter.confirm({
message: MESSAGES.snsFifoPrompt,
});
if (this.isFifo) {
this.logger.logSeparator(MESSAGES.headerDedup);
await this.logger.log(MESSAGES.deduplicationNotice);
await this.logger.log(MESSAGES.deduplicationDescription);
this.autoDedup = await this.prompter.confirm({
message: MESSAGES.deduplicationPrompt,
});
}
}
async createTopic() {
await this.logger.log(MESSAGES.creatingTopics);
this.topicName = await this.prompter.input({
message: MESSAGES.topicNamePrompt,
});
if (this.isFifo) {
this.topicName += ".fifo";
this.logger.logSeparator(MESSAGES.headerFifoNaming);
await this.logger.log(MESSAGES.appendFifoNotice);
}
const response = await this.snsClient.send(
new CreateTopicCommand({
Name: this.topicName,
Attributes: {
FifoTopic: this.isFifo ? "true" : "false",
...(this.autoDedup ? { ContentBasedDeduplication: "true" } : {}),
},
}),
);
this.topicArn = response.TopicArn;
await this.logger.log(
MESSAGES.topicCreatedNotice
.replace("${TOPIC_NAME}", this.topicName)
.replace("${TOPIC_ARN}", this.topicArn),
);
}
async createQueues() {
await this.logger.log(MESSAGES.createQueuesNotice);
// Increase this number to add more queues.
const maxQueues = 2;
for (let i = 0; i < maxQueues; i++) {
await this.logger.log(MESSAGES.queueCount.replace("${COUNT}", i + 1));
let queueName = await this.prompter.input({
message: MESSAGES.queueNamePrompt.replace(
"${EXAMPLE_NAME}",
i === 0 ? "good-news" : "bad-news",
),
});
if (this.isFifo) {
queueName += ".fifo";
await this.logger.log(MESSAGES.appendFifoNotice);
}
const response = await this.sqsClient.send(
new CreateQueueCommand({
QueueName: queueName,
Attributes: { ...(this.isFifo ? { FifoQueue: "true" } : {}) },
}),
);
const { Attributes } = await this.sqsClient.send(
new GetQueueAttributesCommand({
QueueUrl: response.QueueUrl,
AttributeNames: ["QueueArn"],
}),
);
this.queues.push({
queueName,
queueArn: Attributes.QueueArn,
queueUrl: response.QueueUrl,
});
await this.logger.log(
MESSAGES.queueCreatedNotice
.replace("${QUEUE_NAME}", queueName)
.replace("${QUEUE_URL}", response.QueueUrl)
.replace("${QUEUE_ARN}", Attributes.QueueArn),
);
}
}
async attachQueueIamPolicies() {
for (const [index, queue] of this.queues.entries()) {
const policy = JSON.stringify(
{
Statement: [
{
Effect: "Allow",
Principal: {
Service: "sns.amazonaws.com",
},
Action: "sqs:SendMessage",
Resource: queue.queueArn,
Condition: {
ArnEquals: {
"aws:SourceArn": this.topicArn,
},
},
},
],
},
null,
2,
);
if (index !== 0) {
this.logger.logSeparator();
}
await this.logger.log(MESSAGES.attachPolicyNotice);
console.log(policy);
const addPolicy = await this.prompter.confirm({
message: MESSAGES.addPolicyConfirmation.replace(
"${QUEUE_NAME}",
queue.queueName,
),
});
if (addPolicy) {
await this.sqsClient.send(
new SetQueueAttributesCommand({
QueueUrl: queue.queueUrl,
Attributes: {
Policy: policy,
},
}),
);
queue.policy = policy;
} else {
await this.logger.log(
MESSAGES.policyNotAttachedNotice.replace(
"${QUEUE_NAME}",
queue.queueName,
),
);
}
}
}
async subscribeQueuesToTopic() {
for (const [index, queue] of this.queues.entries()) {
/**
* @type {import('@aws-sdk/client-sns').SubscribeCommandInput}
*/
const subscribeParams = {
TopicArn: this.topicArn,
Protocol: "sqs",
Endpoint: queue.queueArn,
};
let tones = [];
if (this.isFifo) {
if (index === 0) {
await this.logger.log(MESSAGES.fifoFilterNotice);
}
tones = await this.prompter.checkbox({
message: MESSAGES.fifoFilterSelect.replace(
"${QUEUE_NAME}",
queue.queueName,
),
choices: toneChoices,
});
if (tones.length) {
subscribeParams.Attributes = {
FilterPolicyScope: "MessageAttributes",
FilterPolicy: JSON.stringify({
tone: tones,
}),
};
}
}
const { SubscriptionArn } = await this.snsClient.send(
new SubscribeCommand(subscribeParams),
);
this.subscriptionArns.push(SubscriptionArn);
await this.logger.log(
MESSAGES.queueSubscribedNotice
.replace("${QUEUE_NAME}", queue.queueName)
.replace("${TOPIC_NAME}", this.topicName)
.replace("${TONES}", tones.length ? tones.join(", ") : "none"),
);
}
}
async publishMessages() {
const message = await this.prompter.input({
message: MESSAGES.publishMessagePrompt,
});
let groupId;
let deduplicationId;
let choices;
if (this.isFifo) {
await this.logger.log(MESSAGES.groupIdNotice);
groupId = await this.prompter.input({
message: MESSAGES.groupIdPrompt,
});
if (this.autoDedup === false) {
await this.logger.log(MESSAGES.deduplicationIdNotice);
deduplicationId = await this.prompter.input({
message: MESSAGES.deduplicationIdPrompt,
});
}
choices = await this.prompter.checkbox({
message: MESSAGES.messageAttributesPrompt,
choices: toneChoices,
});
}
await this.snsClient.send(
new PublishCommand({
TopicArn: this.topicArn,
Message: message,
...(groupId
? {
MessageGroupId: groupId,
}
: {}),
...(deduplicationId
? {
MessageDeduplicationId: deduplicationId,
}
: {}),
...(choices
? {
MessageAttributes: {
tone: {
DataType: "String.Array",
StringValue: JSON.stringify(choices),
},
},
}
: {}),
}),
);
const publishAnother = await this.prompter.confirm({
message: MESSAGES.publishAnother,
});
if (publishAnother) {
await this.publishMessages();
}
}
async receiveAndDeleteMessages() {
for (const queue of this.queues) {
const { Messages } = await this.sqsClient.send(
new ReceiveMessageCommand({
QueueUrl: queue.queueUrl,
}),
);
if (Messages) {
await this.logger.log(
MESSAGES.messagesReceivedNotice.replace(
"${QUEUE_NAME}",
queue.queueName,
),
);
console.log(Messages);
await this.sqsClient.send(
new DeleteMessageBatchCommand({
QueueUrl: queue.queueUrl,
Entries: Messages.map((message) => ({
Id: message.MessageId,
ReceiptHandle: message.ReceiptHandle,
})),
}),
);
} else {
await this.logger.log(
MESSAGES.noMessagesReceivedNotice.replace(
"${QUEUE_NAME}",
queue.queueName,
),
);
}
}
const deleteAndPoll = await this.prompter.confirm({
message: MESSAGES.deleteAndPollConfirmation,
});
if (deleteAndPoll) {
await this.receiveAndDeleteMessages();
}
}
async destroyResources() {
for (const subscriptionArn of this.subscriptionArns) {
await this.snsClient.send(
new UnsubscribeCommand({ SubscriptionArn: subscriptionArn }),
);
}
for (const queue of this.queues) {
await this.sqsClient.send(
new DeleteQueueCommand({ QueueUrl: queue.queueUrl }),
);
}
if (this.topicArn) {
await this.snsClient.send(
new DeleteTopicCommand({ TopicArn: this.topicArn }),
);
}
}
async start() {
console.clear();
try {
this.logger.logSeparator(MESSAGES.headerWelcome);
await this.welcome();
this.logger.logSeparator(MESSAGES.headerFifo);
await this.confirmFifo();
this.logger.logSeparator(MESSAGES.headerCreateTopic);
await this.createTopic();
this.logger.logSeparator(MESSAGES.headerCreateQueues);
await this.createQueues();
this.logger.logSeparator(MESSAGES.headerAttachPolicy);
await this.attachQueueIamPolicies();
this.logger.logSeparator(MESSAGES.headerSubscribeQueues);
await this.subscribeQueuesToTopic();
this.logger.logSeparator(MESSAGES.headerPublishMessage);
await this.publishMessages();
this.logger.logSeparator(MESSAGES.headerReceiveMessages);
await this.receiveAndDeleteMessages();
} catch (err) {
console.error(err);
} finally {
await this.destroyResources();
}
}
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para JavaScript *.
+ [CreateQueue](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/CreateQueueCommand)
+ [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)
+ [DeleteMessageBatch](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/DeleteMessageBatchCommand)
+ [DeleteQueue](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/DeleteQueueCommand)
+ [DeleteTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/DeleteTopicCommand)
+ [GetQueueAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/GetQueueAttributesCommand)
+ [Publish](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/PublishCommand)
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/ReceiveMessageCommand)
+ [SetQueueAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/SetQueueAttributesCommand)
+ [Subscribe](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/SubscribeCommand)
+ [Unsubscribe](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/UnsubscribeCommand)
## Ejemplos de tecnología sin servidor
### Invocar una función de Lambda desde un desencadenador de Amazon SQS
En el siguiente ejemplo de código se muestra cómo implementar una función de Lambda que recibe un evento activado al recibir mensajes de una cola de SQS. La función recupera los mensajes del parámetro de eventos y registra el contenido de cada mensaje.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/blob/main/integration-sqs-to-lambda).
Consumir un evento de SQS con JavaScript Lambda mediante.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
exports.handler = async (event, context) => {
for (const message of event.Records) {
await processMessageAsync(message);
}
console.info("done");
};
async function processMessageAsync(message) {
try {
console.log(`Processed message ${message.body}`);
// TODO: Do interesting work based on the new message
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
Consumir un evento de SQS con TypeScript Lambda mediante.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SQSEvent, Context, SQSHandler, SQSRecord } from "aws-lambda";
export const functionHandler: SQSHandler = async (
event: SQSEvent,
context: Context
): Promise => {
for (const message of event.Records) {
await processMessageAsync(message);
}
console.info("done");
};
async function processMessageAsync(message: SQSRecord): Promise {
try {
console.log(`Processed message ${message.body}`);
// TODO: Do interesting work based on the new message
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
### Notificación de los errores de los elementos del lote de las funciones de Lambda mediante un desencadenador de Amazon SQS.
En el siguiente ejemplo de código se muestra cómo implementar una respuesta por lotes parcial para funciones de Lambda que reciben eventos de una cola de SQS. La función informa los errores de los elementos del lote en la respuesta y le indica a Lambda que vuelva a intentar esos mensajes más adelante.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures).
Informe de errores de artículos de lotes de SQS con JavaScript Lambda mediante.
```
// Node.js 20.x Lambda runtime, AWS SDK for Javascript V3
export const handler = async (event, context) => {
const batchItemFailures = [];
for (const record of event.Records) {
try {
await processMessageAsync(record, context);
} catch (error) {
batchItemFailures.push({ itemIdentifier: record.messageId });
}
}
return { batchItemFailures };
};
async function processMessageAsync(record, context) {
if (record.body && record.body.includes("error")) {
throw new Error("There is an error in the SQS Message.");
}
console.log(`Processed message: ${record.body}`);
}
```
Informe de errores de artículos de lotes de SQS con TypeScript Lambda mediante.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SQSEvent, SQSBatchResponse, Context, SQSBatchItemFailure, SQSRecord } from 'aws-lambda';
export const handler = async (event: SQSEvent, context: Context): Promise => {
const batchItemFailures: SQSBatchItemFailure[] = [];
for (const record of event.Records) {
try {
await processMessageAsync(record);
} catch (error) {
batchItemFailures.push({ itemIdentifier: record.messageId });
}
}
return {batchItemFailures: batchItemFailures};
};
async function processMessageAsync(record: SQSRecord): Promise {
if (record.body && record.body.includes("error")) {
throw new Error('There is an error in the SQS Message.');
}
console.log(`Processed message ${record.body}`);
}
```
# Ejemplos de Step Functions con el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante la AWS SDK para JavaScript (v3) con Step Functions.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Acciones](#actions)
## Acciones
### `StartExecution`
En el siguiente ejemplo de código, se muestra cómo utilizar `StartExecution`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sfn#code-examples).
```
import { SFNClient, StartExecutionCommand } from "@aws-sdk/client-sfn";
/**
* @param {{ sfnClient: SFNClient, stateMachineArn: string }} config
*/
export async function startExecution({ sfnClient, stateMachineArn }) {
const response = await sfnClient.send(
new StartExecutionCommand({
stateMachineArn,
}),
);
console.log(response);
// Example response:
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '202a9309-c16a-454b-adeb-c4d19afe3bf2',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// executionArn: 'arn:aws:states:us-east-1:000000000000:execution:MyStateMachine:aaaaaaaa-f787-49fb-a20c-1b61c64eafe6',
// startDate: 2024-01-04T15:54:08.362Z
// }
return response;
}
// Call function if run directly
import { fileURLToPath } from "node:url";
if (process.argv[1] === fileURLToPath(import.meta.url)) {
startExecution({ sfnClient: new SFNClient({}), stateMachineArn: "ARN" });
}
```
+ Para obtener más información sobre la API, consulta [StartExecution](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sfn/command/StartExecutionCommand)la *Referencia AWS SDK para JavaScript de la API*.
# AWS STS ejemplos de uso del SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de AWS SDK para JavaScript (v3) con. AWS STS
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Acciones](#actions)
## Acciones
### `AssumeRole`
En el siguiente ejemplo de código, se muestra cómo utilizar `AssumeRole`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sts#code-examples).
Cree el cliente.
```
import { STSClient } from "@aws-sdk/client-sts";
// Set the AWS Region.
const REGION = "us-east-1";
// Create an AWS STS service client object.
export const client = new STSClient({ region: REGION });
```
Asuma el rol de IAM.
```
import { AssumeRoleCommand } from "@aws-sdk/client-sts";
import { client } from "../libs/client.js";
export const main = async () => {
try {
// Returns a set of temporary security credentials that you can use to
// access Amazon Web Services resources that you might not normally
// have access to.
const command = new AssumeRoleCommand({
// The Amazon Resource Name (ARN) of the role to assume.
RoleArn: "ROLE_ARN",
// An identifier for the assumed role session.
RoleSessionName: "session1",
// The duration, in seconds, of the role session. The value specified
// can range from 900 seconds (15 minutes) up to the maximum session
// duration set for the role.
DurationSeconds: 900,
});
const response = await client.send(command);
console.log(response);
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [AssumeRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sts/command/AssumeRoleCommand)la *Referencia AWS SDK para JavaScript de la API*.
# Soporte ejemplos de uso del SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de AWS SDK para JavaScript (v3) con. Soporte
Los *conceptos básicos* son ejemplos de código que muestran cómo realizar las operaciones esenciales dentro de un servicio.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Introducción](#get_started)
+ [Conceptos básicos](#basics)
+ [Acciones](#actions)
## Introducción
### Hola Soporte
En el siguiente ejemplo de código se muestra cómo empezar a utilizar Soporte.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
Invoque ‘main()’ para ejecutar el ejemplo.
```
import {
DescribeServicesCommand,
SupportClient,
} from "@aws-sdk/client-support";
// Change the value of 'region' to your preferred AWS Region.
const client = new SupportClient({ region: "us-east-1" });
const getServiceCount = async () => {
try {
const { services } = await client.send(new DescribeServicesCommand({}));
return services.length;
} catch (err) {
if (err.name === "SubscriptionRequiredException") {
throw new Error(
"You must be subscribed to the AWS Support plan to use this feature.",
);
}
throw err;
}
};
export const main = async () => {
try {
const count = await getServiceCount();
console.log(`Hello, AWS Support! There are ${count} services available.`);
} catch (err) {
console.error("Failed to get service count: ", err.message);
}
};
```
+ Para obtener más información sobre la API, consulta [DescribeServices](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeServicesCommand)la *Referencia AWS SDK para JavaScript de la API*.
## Conceptos básicos
### Conceptos básicos
En el siguiente ejemplo de código, se muestra cómo:
+ Obtenga y muestre los servicios disponibles y los niveles de gravedad de los casos.
+ Cree un caso de asistencia mediante un servicio, una categoría y un nivel de gravedad seleccionados.
+ Obtenga y muestre una lista de casos abiertos para el día actual.
+ Añada una serie de archivos adjuntos y una comunicación al nuevo caso.
+ Describa el nuevo archivo adjunto y la comunicación del caso.
+ Resuelva el caso.
+ Obtenga y muestre una lista de casos resueltos para el día actual.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
Ejecute un escenario interactivo en el terminal.
```
import {
AddAttachmentsToSetCommand,
AddCommunicationToCaseCommand,
CreateCaseCommand,
DescribeAttachmentCommand,
DescribeCasesCommand,
DescribeCommunicationsCommand,
DescribeServicesCommand,
DescribeSeverityLevelsCommand,
ResolveCaseCommand,
SupportClient,
} from "@aws-sdk/client-support";
import * as inquirer from "@inquirer/prompts";
import { retry } from "@aws-doc-sdk-examples/lib/utils/util-timers.js";
const wrapText = (text, char = "=") => {
const rule = char.repeat(80);
return `${rule}\n ${text}\n${rule}\n`;
};
const client = new SupportClient({ region: "us-east-1" });
// Verify that the account has a Support plan.
export const verifyAccount = async () => {
const command = new DescribeServicesCommand({});
try {
await client.send(command);
} catch (err) {
if (err.name === "SubscriptionRequiredException") {
throw new Error(
"You must be subscribed to the AWS Support plan to use this feature.",
);
}
throw err;
}
};
/**
* Select a service from the list returned from DescribeServices.
*/
export const getService = async () => {
const { services } = await client.send(new DescribeServicesCommand({}));
const selectedService = await inquirer.select({
message:
"Select a service. Your support case will be created for this service. The list of services is truncated for readability.",
choices: services.slice(0, 10).map((s) => ({ name: s.name, value: s })),
});
return selectedService;
};
/**
* @param {{ categories: import('@aws-sdk/client-support').Category[]}} service
*/
export const getCategory = async (service) => {
const selectedCategory = await inquirer.select({
message: "Select a category.",
choices: service.categories.map((c) => ({ name: c.name, value: c })),
});
return selectedCategory;
};
// Get the available severity levels for the account.
export const getSeverityLevel = async () => {
const command = new DescribeSeverityLevelsCommand({});
const { severityLevels } = await client.send(command);
const selectedSeverityLevel = await inquirer.select({
message: "Select a severity level.",
choices: severityLevels.map((s) => ({ name: s.name, value: s })),
});
return selectedSeverityLevel;
};
/**
* Create a new support case
* @param {{
* selectedService: import('@aws-sdk/client-support').Service
* selectedCategory: import('@aws-sdk/client-support').Category
* selectedSeverityLevel: import('@aws-sdk/client-support').SeverityLevel
* }} selections
* @returns
*/
export const createCase = async ({
selectedService,
selectedCategory,
selectedSeverityLevel,
}) => {
const command = new CreateCaseCommand({
subject: "IGNORE: Test case",
communicationBody: "This is a test. Please ignore.",
serviceCode: selectedService.code,
categoryCode: selectedCategory.code,
severityCode: selectedSeverityLevel.code,
});
const { caseId } = await client.send(command);
return caseId;
};
// Get a list of open support cases created today.
export const getTodaysOpenCases = async () => {
const d = new Date();
const startOfToday = new Date(d.getFullYear(), d.getMonth(), d.getDate());
const command = new DescribeCasesCommand({
includeCommunications: false,
afterTime: startOfToday.toISOString(),
});
const { cases } = await client.send(command);
if (cases.length === 0) {
throw new Error(
"Unexpected number of cases. Expected more than 0 open cases.",
);
}
return cases;
};
// Create an attachment set.
export const createAttachmentSet = async () => {
const command = new AddAttachmentsToSetCommand({
attachments: [
{
fileName: "example.txt",
data: new TextEncoder().encode("some example text"),
},
],
});
const { attachmentSetId } = await client.send(command);
return attachmentSetId;
};
export const linkAttachmentSetToCase = async (attachmentSetId, caseId) => {
const command = new AddCommunicationToCaseCommand({
attachmentSetId,
caseId,
communicationBody: "Adding attachment set to case.",
});
await client.send(command);
};
// Get all communications for a support case.
export const getCommunications = async (caseId) => {
const command = new DescribeCommunicationsCommand({
caseId,
});
const { communications } = await client.send(command);
return communications;
};
/**
* @param {import('@aws-sdk/client-support').Communication[]} communications
*/
export const getFirstAttachment = (communications) => {
const firstCommWithAttachment = communications.find(
(c) => c.attachmentSet.length > 0,
);
return firstCommWithAttachment?.attachmentSet[0].attachmentId;
};
// Get an attachment.
export const getAttachment = async (attachmentId) => {
const command = new DescribeAttachmentCommand({
attachmentId,
});
const { attachment } = await client.send(command);
return attachment;
};
// Resolve the case matching the given case ID.
export const resolveCase = async (caseId) => {
const shouldResolve = await inquirer.confirm({
message: `Do you want to resolve ${caseId}?`,
});
if (shouldResolve) {
const command = new ResolveCaseCommand({
caseId: caseId,
});
await client.send(command);
return true;
}
return false;
};
/**
* Find a specific case in the list of provided cases by case ID.
* If the case is not found, and the results are paginated, continue
* paging through the results.
* @param {{
* caseId: string,
* cases: import('@aws-sdk/client-support').CaseDetails[]
* nextToken: string
* }} options
* @returns
*/
export const findCase = async ({ caseId, cases, nextToken }) => {
const foundCase = cases.find((c) => c.caseId === caseId);
if (foundCase) {
return foundCase;
}
if (nextToken) {
const response = await client.send(
new DescribeCasesCommand({
nextToken,
includeResolvedCases: true,
}),
);
return findCase({
caseId,
cases: response.cases,
nextToken: response.nextToken,
});
}
throw new Error(`${caseId} not found.`);
};
// Get all cases created today.
export const getTodaysResolvedCases = async (caseIdToWaitFor) => {
const d = new Date("2023-01-18");
const startOfToday = new Date(d.getFullYear(), d.getMonth(), d.getDate());
const command = new DescribeCasesCommand({
includeCommunications: false,
afterTime: startOfToday.toISOString(),
includeResolvedCases: true,
});
const { cases, nextToken } = await client.send(command);
await findCase({ cases, caseId: caseIdToWaitFor, nextToken });
return cases.filter((c) => c.status === "resolved");
};
const main = async () => {
let caseId;
try {
console.log(wrapText("Welcome to the AWS Support basic usage scenario."));
// Verify that the account is subscribed to support.
await verifyAccount();
// Provided a truncated list of services and prompt the user to select one.
const selectedService = await getService();
// Provided the categories for the selected service and prompt the user to select one.
const selectedCategory = await getCategory(selectedService);
// Provide the severity available severity levels for the account and prompt the user to select one.
const selectedSeverityLevel = await getSeverityLevel();
// Create a support case.
console.log("\nCreating a support case.");
caseId = await createCase({
selectedService,
selectedCategory,
selectedSeverityLevel,
});
console.log(`Support case created: ${caseId}`);
// Display a list of open support cases created today.
const todaysOpenCases = await retry(
{ intervalInMs: 1000, maxRetries: 15 },
getTodaysOpenCases,
);
console.log(
`\nOpen support cases created today: ${todaysOpenCases.length}`,
);
console.log(todaysOpenCases.map((c) => `${c.caseId}`).join("\n"));
// Create an attachment set.
console.log("\nCreating an attachment set.");
const attachmentSetId = await createAttachmentSet();
console.log(`Attachment set created: ${attachmentSetId}`);
// Add the attachment set to the support case.
console.log(`\nAdding attachment set to ${caseId}`);
await linkAttachmentSetToCase(attachmentSetId, caseId);
console.log(`Attachment set added to ${caseId}`);
// List the communications for a support case.
console.log(`\nListing communications for ${caseId}`);
const communications = await getCommunications(caseId);
console.log(
communications
.map(
(c) =>
`Communication created on ${c.timeCreated}. Has ${c.attachmentSet.length} attachments.`,
)
.join("\n"),
);
// Describe the first attachment.
console.log(`\nDescribing attachment ${attachmentSetId}`);
const attachmentId = getFirstAttachment(communications);
const attachment = await getAttachment(attachmentId);
console.log(
`Attachment is the file '${
attachment.fileName
}' with data: \n${new TextDecoder().decode(attachment.data)}`,
);
// Confirm that the support case should be resolved.
const isResolved = await resolveCase(caseId);
if (isResolved) {
// List the resolved cases and include the one previously created.
// Resolved cases can take a while to appear.
console.log(
"\nWaiting for case status to be marked as resolved. This can take some time.",
);
const resolvedCases = await retry(
{ intervalInMs: 20000, maxRetries: 15 },
() => getTodaysResolvedCases(caseId),
);
console.log("Resolved cases:");
console.log(resolvedCases.map((c) => c.caseId).join("\n"));
}
} catch (err) {
console.error(err);
}
};
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para JavaScript *.
+ [AddAttachmentsToSet](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/AddAttachmentsToSetCommand)
+ [AddCommunicationToCase](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/AddCommunicationToCaseCommand)
+ [CreateCase](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/CreateCaseCommand)
+ [DescribeAttachment](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeAttachmentCommand)
+ [DescribeCases](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeCasesCommand)
+ [DescribeCommunications](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeCommunicationsCommand)
+ [DescribeServices](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeServicesCommand)
+ [DescribeSeverityLevels](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeSeverityLevelsCommand)
+ [ResolveCase](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/ResolveCaseCommand)
## Acciones
### `AddAttachmentsToSet`
En el siguiente ejemplo de código, se muestra cómo utilizar `AddAttachmentsToSet`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { AddAttachmentsToSetCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
export const main = async () => {
try {
// Create a new attachment set or add attachments to an existing set.
// Provide an 'attachmentSetId' value to add attachments to an existing set.
// Use AddCommunicationToCase or CreateCase to associate an attachment set with a support case.
const response = await client.send(
new AddAttachmentsToSetCommand({
// You can add up to three attachments per set. The size limit is 5 MB per attachment.
attachments: [
{
fileName: "example.txt",
data: new TextEncoder().encode("some example text"),
},
],
}),
);
// Use this ID in AddCommunicationToCase or CreateCase.
console.log(response.attachmentSetId);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [AddAttachmentsToSet](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/AddAttachmentsToSetCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `AddCommunicationToCase`
En el siguiente ejemplo de código, se muestra cómo utilizar `AddCommunicationToCase`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { AddCommunicationToCaseCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
export const main = async () => {
let attachmentSetId;
try {
// Add a communication to a case.
const response = await client.send(
new AddCommunicationToCaseCommand({
communicationBody: "Adding an attachment.",
// Set value to an existing support case id.
caseId: "CASE_ID",
// Optional. Set value to an existing attachment set id to add attachments to the case.
attachmentSetId,
}),
);
console.log(response);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [AddCommunicationToCase](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/AddCommunicationToCaseCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateCase`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateCase`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { CreateCaseCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
export const main = async () => {
try {
// Create a new case and log the case id.
// Important: This creates a real support case in your account.
const response = await client.send(
new CreateCaseCommand({
// The subject line of the case.
subject: "IGNORE: Test case",
// Use DescribeServices to find available service codes for each service.
serviceCode: "service-quicksight-end-user",
// Use DescribeSecurityLevels to find available severity codes for your support plan.
severityCode: "low",
// Use DescribeServices to find available category codes for each service.
categoryCode: "end-user-support",
// The main description of the support case.
communicationBody: "This is a test. Please ignore.",
}),
);
console.log(response.caseId);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [CreateCase](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/CreateCaseCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DescribeAttachment`
En el siguiente ejemplo de código, se muestra cómo utilizar `DescribeAttachment`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { DescribeAttachmentCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
export const main = async () => {
try {
// Get the metadata and content of an attachment.
const response = await client.send(
new DescribeAttachmentCommand({
// Set value to an existing attachment id.
// Use DescribeCommunications or DescribeCases to find an attachment id.
attachmentId: "ATTACHMENT_ID",
}),
);
console.log(response.attachment?.fileName);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [DescribeAttachment](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeAttachmentCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DescribeCases`
En el siguiente ejemplo de código, se muestra cómo utilizar `DescribeCases`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { DescribeCasesCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
export const main = async () => {
try {
// Get all of the unresolved cases in your account.
// Filter or expand results by providing parameters to the DescribeCasesCommand. Refer
// to the TypeScript definition and the API doc for more information on possible parameters.
// https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-support/interfaces/describecasescommandinput.html
const response = await client.send(new DescribeCasesCommand({}));
const caseIds = response.cases.map((supportCase) => supportCase.caseId);
console.log(caseIds);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [DescribeCases](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeCasesCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DescribeCommunications`
En el siguiente ejemplo de código, se muestra cómo utilizar `DescribeCommunications`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { DescribeCommunicationsCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
export const main = async () => {
try {
// Get all communications for the support case.
// Filter results by providing parameters to the DescribeCommunicationsCommand. Refer
// to the TypeScript definition and the API doc for more information on possible parameters.
// https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-support/interfaces/describecommunicationscommandinput.html
const response = await client.send(
new DescribeCommunicationsCommand({
// Set value to an existing case id.
caseId: "CASE_ID",
}),
);
const text = response.communications.map((item) => item.body).join("\n");
console.log(text);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [DescribeCommunications](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeCommunicationsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DescribeSeverityLevels`
En el siguiente ejemplo de código, se muestra cómo utilizar `DescribeSeverityLevels`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { DescribeSeverityLevelsCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
export const main = async () => {
try {
// Get the list of severity levels.
// The available values depend on the support plan for the account.
const response = await client.send(new DescribeSeverityLevelsCommand({}));
console.log(response.severityLevels);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [DescribeSeverityLevels](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/DescribeSeverityLevelsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ResolveCase`
En el siguiente ejemplo de código, se muestra cómo utilizar `ResolveCase`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/support#code-examples).
```
import { ResolveCaseCommand } from "@aws-sdk/client-support";
import { client } from "../libs/client.js";
const main = async () => {
try {
const response = await client.send(
new ResolveCaseCommand({
caseId: "CASE_ID",
}),
);
console.log(response.finalCaseStatus);
return response;
} catch (err) {
console.error(err);
}
};
```
+ Para obtener más información sobre la API, consulta [ResolveCase](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/support/command/ResolveCaseCommand)la *Referencia AWS SDK para JavaScript de la API*.
# Ejemplos de Systems Manager que utilizan el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante la AWS SDK para JavaScript (v3) con Systems Manager.
Los *conceptos básicos* son ejemplos de código que muestran cómo realizar las operaciones esenciales dentro de un servicio.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Introducción](#get_started)
+ [Conceptos básicos](#basics)
+ [Acciones](#actions)
## Introducción
### Hola, Systems Manager
En el siguiente ejemplo de código, se muestra cómo empezar a utilizar Systems Manager.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { paginateListDocuments, SSMClient } from "@aws-sdk/client-ssm";
// Call ListDocuments and display the result.
export const main = async () => {
const client = new SSMClient();
const listDocumentsPaginated = [];
console.log(
"Hello, AWS Systems Manager! Let's list some of your documents:\n",
);
try {
// The paginate function is a wrapper around the base command.
const paginator = paginateListDocuments({ client }, { MaxResults: 5 });
for await (const page of paginator) {
listDocumentsPaginated.push(...page.DocumentIdentifiers);
}
} catch (caught) {
console.error(`There was a problem saying hello: ${caught.message}`);
throw caught;
}
for (const { Name, DocumentFormat, CreatedDate } of listDocumentsPaginated) {
console.log(`${Name} - ${DocumentFormat} - ${CreatedDate}`);
}
};
// Call function if run directly.
import { fileURLToPath } from "node:url";
if (process.argv[1] === fileURLToPath(import.meta.url)) {
main();
}
```
+ Para obtener más información sobre la API, consulta [ListDocuments](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/ListDocumentsCommand)la *Referencia AWS SDK para JavaScript de la API*.
## Conceptos básicos
### Conceptos básicos
En el siguiente ejemplo de código, se muestra cómo:
+ Crear un período de mantenimiento.
+ Modificar la programación del período de mantenimiento.
+ Cree un documento.
+ Enviar un comando a una instancia de EC2 especificada.
+ Crea un OpsItem.
+ Actualice y resuelva el OpsItem.
+ Elimine la ventana de mantenimiento OpsItem y el documento.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import {
Scenario,
ScenarioAction,
ScenarioInput,
ScenarioOutput,
} from "@aws-doc-sdk-examples/lib/scenario/index.js";
import { fileURLToPath } from "node:url";
import {
CreateDocumentCommand,
CreateMaintenanceWindowCommand,
CreateOpsItemCommand,
DeleteDocumentCommand,
DeleteMaintenanceWindowCommand,
DeleteOpsItemCommand,
DescribeOpsItemsCommand,
DocumentAlreadyExists,
OpsItemStatus,
waitUntilCommandExecuted,
CancelCommandCommand,
paginateListCommandInvocations,
SendCommandCommand,
UpdateMaintenanceWindowCommand,
UpdateOpsItemCommand,
SSMClient,
} from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* @typedef {{
* ssmClient: import('@aws-sdk/client-ssm').SSMClient,
* documentName?: string
* maintenanceWindow?: string
* winId?: int
* ec2InstanceId?: string
* requestedDateTime?: Date
* opsItemId?: string
* askToDeleteResources?: boolean
* }} State
*/
const defaultMaintenanceWindow = "ssm-maintenance-window";
const defaultDocumentName = "ssmdocument";
// The timeout duration is highly dependent on the specific setup and environment necessary. This example handles only the most common error cases, and uses a much shorter duration than most productions systems would use.
const COMMAND_TIMEOUT_DURATION_SECONDS = 30; // 30 seconds
const pressEnter = new ScenarioInput("continue", "Press Enter to continue", {
type: "confirm",
});
const greet = new ScenarioOutput(
"greet",
`Welcome to the AWS Systems Manager SDK Getting Started scenario.
This program demonstrates how to interact with Systems Manager using the AWS SDK for JavaScript V3.
Systems Manager is the operations hub for your AWS applications and resources and a secure end-to-end management solution.
The program's primary functions include creating a maintenance window, creating a document, sending a command to a document,
listing documents, listing commands, creating an OpsItem, modifying an OpsItem, and deleting Systems Manager resources.
Upon completion of the program, all AWS resources are cleaned up.
Let's get started...`,
{ header: true },
);
const createMaintenanceWindow = new ScenarioOutput(
"createMaintenanceWindow",
"Step 1: Create a Systems Manager maintenance window.",
);
const getMaintenanceWindow = new ScenarioInput(
"maintenanceWindow",
"Please enter the maintenance window name:",
{ type: "input", default: defaultMaintenanceWindow },
);
export const sdkCreateMaintenanceWindow = new ScenarioAction(
"sdkCreateMaintenanceWindow",
async (/** @type {State} */ state) => {
try {
const response = await state.ssmClient.send(
new CreateMaintenanceWindowCommand({
Name: state.maintenanceWindow,
Schedule: "cron(0 10 ? * MON-FRI *)", //The schedule of the maintenance window in the form of a cron or rate expression.
Duration: 2, //The duration of the maintenance window in hours.
Cutoff: 1, //The number of hours before the end of the maintenance window that Amazon Web Services Systems Manager stops scheduling new tasks for execution.
AllowUnassociatedTargets: true, //Allow the maintenance window to run on managed nodes, even if you haven't registered those nodes as targets.
}),
);
state.winId = response.WindowId;
} catch (caught) {
console.error(caught.message);
console.log(
`An error occurred while creating the maintenance window. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
},
);
const modifyMaintenanceWindow = new ScenarioOutput(
"modifyMaintenanceWindow",
"Modify the maintenance window by changing the schedule.",
);
const sdkModifyMaintenanceWindow = new ScenarioAction(
"sdkModifyMaintenanceWindow",
async (/** @type {State} */ state) => {
try {
await state.ssmClient.send(
new UpdateMaintenanceWindowCommand({
WindowId: state.winId,
Schedule: "cron(0 0 ? * MON *)",
}),
);
} catch (caught) {
console.error(caught.message);
console.log(
`An error occurred while modifying the maintenance window. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
},
);
const createSystemsManagerActions = new ScenarioOutput(
"createSystemsManagerActions",
"Create a document that defines the actions that Systems Manager performs on your EC2 instance.",
);
const getDocumentName = new ScenarioInput(
"documentName",
"Please enter the document: ",
{ type: "input", default: defaultDocumentName },
);
const sdkCreateSSMDoc = new ScenarioAction(
"sdkCreateSSMDoc",
async (/** @type {State} */ state) => {
const contentData = `{
"schemaVersion": "2.2",
"description": "Run a simple shell command",
"mainSteps": [
{
"action": "aws:runShellScript",
"name": "runEchoCommand",
"inputs": {
"runCommand": [
"echo 'Hello, world!'"
]
}
}
]
}`;
try {
await state.ssmClient.send(
new CreateDocumentCommand({
Content: contentData,
Name: state.documentName,
DocumentType: "Command",
}),
);
} catch (caught) {
console.log(`Exception type: (${typeof caught})`);
if (caught instanceof DocumentAlreadyExists) {
console.log("Document already exists. Continuing...\n");
} else {
console.error(caught.message);
console.log(
`An error occurred while creating the document. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
}
},
);
const ec2HelloWorld = new ScenarioOutput(
"ec2HelloWorld",
`Now you have the option of running a command on an EC2 instance that echoes 'Hello, world!'. In order to run this command, you must provide the instance ID of a Linux EC2 instance. If you do not already have a running Linux EC2 instance in your account, you can create one using the AWS console. For information about creating an EC2 instance, see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html.`,
);
const enterIdOrSkipEC2HelloWorld = new ScenarioInput(
"enterIdOrSkipEC2HelloWorld",
"Enter your EC2 InstanceId or press enter to skip this step: ",
{ type: "input", default: "" },
);
const sdkEC2HelloWorld = new ScenarioAction(
"sdkEC2HelloWorld",
async (/** @type {State} */ state) => {
try {
const response = await state.ssmClient.send(
new SendCommandCommand({
DocumentName: state.documentName,
InstanceIds: [state.ec2InstanceId],
TimeoutSeconds: COMMAND_TIMEOUT_DURATION_SECONDS,
}),
);
state.CommandId = response.Command.CommandId;
} catch (caught) {
console.error(caught.message);
console.log(
`An error occurred while sending the command. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
},
{
skipWhen: (/** @type {State} */ state) =>
state.enterIdOrSkipEC2HelloWorld === "",
},
);
const sdkGetCommandTime = new ScenarioAction(
"sdkGetCommandTime",
async (/** @type {State} */ state) => {
const listInvocationsPaginated = [];
console.log(
"Let's get the time when the specific command was sent to the specific managed node.",
);
console.log(
`First, we'll wait for the command to finish executing. This may take up to ${COMMAND_TIMEOUT_DURATION_SECONDS} seconds.`,
);
const commandExecutedResult = waitUntilCommandExecuted(
{ client: state.ssmClient },
{
CommandId: state.CommandId,
InstanceId: state.ec2InstanceId,
},
);
// This is necessary because the TimeoutSeconds of SendCommandCommand is only for the delivery, not execution.
try {
await new Promise((_, reject) =>
setTimeout(
reject,
COMMAND_TIMEOUT_DURATION_SECONDS * 1000,
new Error("Command Timed Out"),
),
);
} catch (caught) {
if (caught.message === "Command Timed Out") {
commandExecutedResult.state = "TIMED_OUT";
} else {
throw caught;
}
}
if (commandExecutedResult.state !== "SUCCESS") {
console.log(
`The command with id: ${state.CommandId} did not execute in the allotted time. Canceling command.`,
);
state.ssmClient.send(
new CancelCommandCommand({
CommandId: state.CommandId,
}),
);
state.enterIdOrSkipEC2HelloWorld === "";
return;
}
for await (const page of paginateListCommandInvocations(
{ client: state.ssmClient },
{ CommandId: state.CommandId },
)) {
listInvocationsPaginated.push(...page.CommandInvocations);
}
/**
* @type {import('@aws-sdk/client-ssm').CommandInvocation}
*/
const commandInvocation = listInvocationsPaginated.shift(); // Because the call was made with CommandId, there's only one result, so shift it off.
state.requestedDateTime = commandInvocation.RequestedDateTime;
console.log(
`The command invocation happened at: ${state.requestedDateTime}.`,
);
},
{
skipWhen: (/** @type {State} */ state) =>
state.enterIdOrSkipEC2HelloWorld === "",
},
);
const createSSMOpsItem = new ScenarioOutput(
"createSSMOpsItem",
`Now we will create a Systems Manager OpsItem. An OpsItem is a feature provided by the Systems Manager service. It is a type of operational data item that allows you to manage and track various operational issues, events, or tasks within your AWS environment.
You can create OpsItems to track and manage operational issues as they arise. For example, you could create an OpsItem whenever your application detects a critical error or an anomaly in your infrastructure.`,
);
const sdkCreateSSMOpsItem = new ScenarioAction(
"sdkCreateSSMOpsItem",
async (/** @type {State} */ state) => {
try {
const response = await state.ssmClient.send(
new CreateOpsItemCommand({
Description: "Created by the System Manager Javascript API",
Title: "Disk Space Alert",
Source: "EC2",
Category: "Performance",
Severity: "2",
}),
);
state.opsItemId = response.OpsItemId;
} catch (caught) {
console.error(caught.message);
console.log(
`An error occurred while creating the ops item. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
},
);
const updateOpsItem = new ScenarioOutput(
"updateOpsItem",
(/** @type {State} */ state) =>
`Now we will update the OpsItem: ${state.opsItemId}`,
);
const sdkUpdateOpsItem = new ScenarioAction(
"sdkUpdateOpsItem",
async (/** @type {State} */ state) => {
try {
const _response = await state.ssmClient.send(
new UpdateOpsItemCommand({
OpsItemId: state.opsItemId,
Description: `An update to ${state.opsItemId}`,
}),
);
} catch (caught) {
console.error(caught.message);
console.log(
`An error occurred while updating the ops item. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
},
);
const getOpsItemStatus = new ScenarioOutput(
"getOpsItemStatus",
(/** @type {State} */ state) =>
`Now we will get the status of the OpsItem: ${state.opsItemId}`,
);
const sdkOpsItemStatus = new ScenarioAction(
"sdkGetOpsItemStatus",
async (/** @type {State} */ state) => {
try {
const response = await state.ssmClient.send(
new DescribeOpsItemsCommand({
OpsItemId: state.opsItemId,
}),
);
state.opsItemStatus = response.OpsItemStatus;
} catch (caught) {
console.error(caught.message);
console.log(
`An error occurred while describing the ops item. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
},
);
const resolveOpsItem = new ScenarioOutput(
"resolveOpsItem",
(/** @type {State} */ state) =>
`Now we will resolve the OpsItem: ${state.opsItemId}`,
);
const sdkResolveOpsItem = new ScenarioAction(
"sdkResolveOpsItem",
async (/** @type {State} */ state) => {
try {
const _response = await state.ssmClient.send(
new UpdateOpsItemCommand({
OpsItemId: state.opsItemId,
Status: OpsItemStatus.RESOLVED,
}),
);
} catch (caught) {
console.error(caught.message);
console.log(
`An error occurred while updating the ops item. Please fix the error and try again. Error message: ${caught.message}`,
);
throw caught;
}
},
);
const askToDeleteResources = new ScenarioInput(
"askToDeleteResources",
"Would you like to delete the Systems Manager resources created during this example run?",
{ type: "confirm" },
);
const confirmDeleteChoice = new ScenarioOutput(
"confirmDeleteChoice",
(/** @type {State} */ state) => {
if (state.askToDeleteResources) {
return "You chose to delete the resources.";
}
return "The Systems Manager resources will not be deleted. Please delete them manually to avoid charges.";
},
);
export const sdkDeleteResources = new ScenarioAction(
"sdkDeleteResources",
async (/** @type {State} */ state) => {
try {
await state.ssmClient.send(
new DeleteOpsItemCommand({
OpsItemId: state.opsItemId,
}),
);
console.log(`The ops item: ${state.opsItemId} was successfully deleted.`);
} catch (caught) {
console.log(
`There was a problem deleting the ops item: ${state.opsItemId}. Please delete it manually. Error: ${caught.message}`,
);
}
try {
await state.ssmClient.send(
new DeleteMaintenanceWindowCommand({
Name: state.maintenanceWindow,
WindowId: state.winId,
}),
);
console.log(
`The maintenance window: ${state.maintenanceWindow} was successfully deleted.`,
);
} catch (caught) {
console.log(
`There was a problem deleting the maintenance window: ${state.opsItemId}. Please delete it manually. Error: ${caught.message}`,
);
}
try {
await state.ssmClient.send(
new DeleteDocumentCommand({
Name: state.documentName,
}),
);
console.log(
`The document: ${state.documentName} was successfully deleted.`,
);
} catch (caught) {
console.log(
`There was a problem deleting the document: ${state.documentName}. Please delete it manually. Error: ${caught.message}`,
);
}
},
{ skipWhen: (/** @type {{}} */ state) => !state.askToDeleteResources },
);
const goodbye = new ScenarioOutput(
"goodbye",
"This concludes the Systems Manager Basics scenario for the AWS Javascript SDK v3. Thank you!",
);
const myScenario = new Scenario(
"SSM Basics",
[
greet,
pressEnter,
createMaintenanceWindow,
getMaintenanceWindow,
sdkCreateMaintenanceWindow,
modifyMaintenanceWindow,
pressEnter,
sdkModifyMaintenanceWindow,
createSystemsManagerActions,
getDocumentName,
sdkCreateSSMDoc,
ec2HelloWorld,
enterIdOrSkipEC2HelloWorld,
sdkEC2HelloWorld,
sdkGetCommandTime,
pressEnter,
createSSMOpsItem,
pressEnter,
sdkCreateSSMOpsItem,
updateOpsItem,
pressEnter,
sdkUpdateOpsItem,
getOpsItemStatus,
pressEnter,
sdkOpsItemStatus,
resolveOpsItem,
pressEnter,
sdkResolveOpsItem,
askToDeleteResources,
confirmDeleteChoice,
sdkDeleteResources,
goodbye,
],
{ ssmClient: new SSMClient({}) },
);
/** @type {{ stepHandlerOptions: StepHandlerOptions }} */
export const main = async (stepHandlerOptions) => {
await myScenario.run(stepHandlerOptions);
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const { values } = parseArgs({
options: {
yes: {
type: "boolean",
short: "y",
},
},
});
main({ confirmAll: values.yes });
}
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para JavaScript *.
+ [CreateDocument](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/CreateDocumentCommand)
+ [CreateMaintenanceWindow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/CreateMaintenanceWindowCommand)
+ [CreateOpsItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/CreateOpsItemCommand)
+ [DeleteMaintenanceWindow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/DeleteMaintenanceWindowCommand)
+ [ListCommandInvocations](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/ListCommandInvocationsCommand)
+ [SendCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/SendCommandCommand)
+ [UpdateOpsItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/UpdateOpsItemCommand)
## Acciones
### `CreateDocument`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateDocument`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { CreateDocumentCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Create an SSM document.
* @param {{ content: string, name: string, documentType?: DocumentType }}
*/
export const main = async ({ content, name, documentType }) => {
const client = new SSMClient({});
try {
const { documentDescription } = await client.send(
new CreateDocumentCommand({
Content: content, // The content for the new SSM document. The content must not exceed 64KB.
Name: name,
DocumentType: documentType, // Document format type can be JSON, YAML, or TEXT. The default format is JSON.
}),
);
console.log("Document created successfully.");
return { DocumentDescription: documentDescription };
} catch (caught) {
if (caught instanceof Error && caught.name === "DocumentAlreadyExists") {
console.warn(`${caught.message}. Did you provide a new document name?`);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [CreateDocument](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/CreateDocumentCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateMaintenanceWindow`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateMaintenanceWindow`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { CreateMaintenanceWindowCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Create an SSM maintenance window.
* @param {{ name: string, allowUnassociatedTargets: boolean, duration: number, cutoff: number, schedule: string, description?: string }}
*/
export const main = async ({
name,
allowUnassociatedTargets, // Allow the maintenance window to run on managed nodes, even if you haven't registered those nodes as targets.
duration, // The duration of the maintenance window in hours.
cutoff, // The number of hours before the end of the maintenance window that Amazon Web Services Systems Manager stops scheduling new tasks for execution.
schedule, // The schedule of the maintenance window in the form of a cron or rate expression.
description = undefined,
}) => {
const client = new SSMClient({});
try {
const { windowId } = await client.send(
new CreateMaintenanceWindowCommand({
Name: name,
Description: description,
AllowUnassociatedTargets: allowUnassociatedTargets, // Allow the maintenance window to run on managed nodes, even if you haven't registered those nodes as targets.
Duration: duration, // The duration of the maintenance window in hours.
Cutoff: cutoff, // The number of hours before the end of the maintenance window that Amazon Web Services Systems Manager stops scheduling new tasks for execution.
Schedule: schedule, // The schedule of the maintenance window in the form of a cron or rate expression.
}),
);
console.log(`Maintenance window created with Id: ${windowId}`);
return { WindowId: windowId };
} catch (caught) {
if (caught instanceof Error && caught.name === "MissingParameter") {
console.warn(`${caught.message}. Did you provide these values?`);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [CreateMaintenanceWindow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/CreateMaintenanceWindowCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `CreateOpsItem`
En el siguiente ejemplo de código, se muestra cómo utilizar `CreateOpsItem`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { CreateOpsItemCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Create an SSM OpsItem.
* @param {{ title: string, source: string, category?: string, severity?: string }}
*/
export const main = async ({
title,
source,
category = undefined,
severity = undefined,
}) => {
const client = new SSMClient({});
try {
const { opsItemArn, opsItemId } = await client.send(
new CreateOpsItemCommand({
Title: title,
Source: source, // The origin of the OpsItem, such as Amazon EC2 or Systems Manager.
Category: category,
Severity: severity,
}),
);
console.log(`Ops item created with id: ${opsItemId}`);
return { OpsItemArn: opsItemArn, OpsItemId: opsItemId };
} catch (caught) {
if (caught instanceof Error && caught.name === "MissingParameter") {
console.warn(`${caught.message}. Did you provide these values?`);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [CreateOpsItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/CreateOpsItemCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteDocument`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteDocument`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { DeleteDocumentCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Delete an SSM document.
* @param {{ documentName: string }}
*/
export const main = async ({ documentName }) => {
const client = new SSMClient({});
try {
await client.send(new DeleteDocumentCommand({ Name: documentName }));
console.log(`Document '${documentName}' deleted.`);
return { Deleted: true };
} catch (caught) {
if (caught instanceof Error && caught.name === "MissingParameter") {
console.warn(`${caught.message}. Did you provide this value?`);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [DeleteDocument](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/DeleteDocumentCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteMaintenanceWindow`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteMaintenanceWindow`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { DeleteMaintenanceWindowCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Delete an SSM maintenance window.
* @param {{ windowId: string }}
*/
export const main = async ({ windowId }) => {
const client = new SSMClient({});
try {
await client.send(
new DeleteMaintenanceWindowCommand({ WindowId: windowId }),
);
console.log(`Maintenance window '${windowId}' deleted.`);
return { Deleted: true };
} catch (caught) {
if (caught instanceof Error && caught.name === "MissingParameter") {
console.warn(`${caught.message}. Did you provide this value?`);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [DeleteMaintenanceWindow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/DeleteMaintenanceWindowCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DescribeOpsItems`
En el siguiente ejemplo de código, se muestra cómo utilizar `DescribeOpsItems`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import {
OpsItemFilterOperator,
OpsItemFilterKey,
paginateDescribeOpsItems,
SSMClient,
} from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Describe SSM OpsItems.
* @param {{ opsItemId: string }}
*/
export const main = async ({ opsItemId }) => {
const client = new SSMClient({});
try {
const describeOpsItemsPaginated = [];
for await (const page of paginateDescribeOpsItems(
{ client },
{
OpsItemFilters: {
Key: OpsItemFilterKey.OPSITEM_ID,
Operator: OpsItemFilterOperator.EQUAL,
Values: opsItemId,
},
},
)) {
describeOpsItemsPaginated.push(...page.OpsItemSummaries);
}
console.log("Here are the ops items:");
console.log(describeOpsItemsPaginated);
return { OpsItemSummaries: describeOpsItemsPaginated };
} catch (caught) {
if (caught instanceof Error && caught.name === "MissingParameter") {
console.warn(`${caught.message}. Did you provide this value?`);
}
throw caught;
}
};
```
+ Para obtener más información sobre la API, consulta [DescribeOpsItems](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/DescribeOpsItemsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListCommandInvocations`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListCommandInvocations`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { paginateListCommandInvocations, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* List SSM command invocations on an instance.
* @param {{ instanceId: string }}
*/
export const main = async ({ instanceId }) => {
const client = new SSMClient({});
try {
const listCommandInvocationsPaginated = [];
// The paginate function is a wrapper around the base command.
const paginator = paginateListCommandInvocations(
{ client },
{
InstanceId: instanceId,
},
);
for await (const page of paginator) {
listCommandInvocationsPaginated.push(...page.CommandInvocations);
}
console.log("Here is the list of command invocations:");
console.log(listCommandInvocationsPaginated);
return { CommandInvocations: listCommandInvocationsPaginated };
} catch (caught) {
if (caught instanceof Error && caught.name === "ValidationError") {
console.warn(`${caught.message}. Did you provide a valid instance ID?`);
}
throw caught;
}
};
```
+ Para obtener más información sobre la API, consulta [ListCommandInvocations](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/ListCommandInvocationsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `SendCommand`
En el siguiente ejemplo de código, se muestra cómo utilizar `SendCommand`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { SendCommandCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Send an SSM command to a managed node.
* @param {{ documentName: string }}
*/
export const main = async ({ documentName }) => {
const client = new SSMClient({});
try {
await client.send(
new SendCommandCommand({
DocumentName: documentName,
}),
);
console.log("Command sent successfully.");
return { Success: true };
} catch (caught) {
if (caught instanceof Error && caught.name === "ValidationError") {
console.warn(`${caught.message}. Did you provide a valid document name?`);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [SendCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/SendCommandCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `UpdateMaintenanceWindow`
En el siguiente ejemplo de código, se muestra cómo utilizar `UpdateMaintenanceWindow`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { UpdateMaintenanceWindowCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Update an SSM maintenance window.
* @param {{ windowId: string, allowUnassociatedTargets?: boolean, duration?: number, enabled?: boolean, name?: string, schedule?: string }}
*/
export const main = async ({
windowId,
allowUnassociatedTargets = undefined, //Allow the maintenance window to run on managed nodes, even if you haven't registered those nodes as targets.
duration = undefined, //The duration of the maintenance window in hours.
enabled = undefined,
name = undefined,
schedule = undefined, //The schedule of the maintenance window in the form of a cron or rate expression.
}) => {
const client = new SSMClient({});
try {
const { opsItemArn, opsItemId } = await client.send(
new UpdateMaintenanceWindowCommand({
WindowId: windowId,
AllowUnassociatedTargets: allowUnassociatedTargets,
Duration: duration,
Enabled: enabled,
Name: name,
Schedule: schedule,
}),
);
console.log("Maintenance window updated.");
return { OpsItemArn: opsItemArn, OpsItemId: opsItemId };
} catch (caught) {
if (caught instanceof Error && caught.name === "ValidationError") {
console.warn(`${caught.message}. Are these values correct?`);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [UpdateMaintenanceWindow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/UpdateMaintenanceWindowCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `UpdateOpsItem`
En el siguiente ejemplo de código, se muestra cómo utilizar `UpdateOpsItem`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ssm#code-examples).
```
import { UpdateOpsItemCommand, SSMClient } from "@aws-sdk/client-ssm";
import { parseArgs } from "node:util";
/**
* Update an SSM OpsItem.
* @param {{ opsItemId: string, status?: OpsItemStatus }}
*/
export const main = async ({
opsItemId,
status = undefined, // The OpsItem status. Status can be Open, In Progress, or Resolved
}) => {
const client = new SSMClient({});
try {
await client.send(
new UpdateOpsItemCommand({
OpsItemId: opsItemId,
Status: status,
}),
);
console.log("Ops item updated.");
return { Success: true };
} catch (caught) {
if (
caught instanceof Error &&
caught.name === "OpsItemLimitExceededException"
) {
console.warn(
`Couldn't create ops item because you have exceeded your open OpsItem limit. ${caught.message}.`,
);
} else {
throw caught;
}
}
};
```
+ Para obtener más información sobre la API, consulta [UpdateOpsItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/ssm/command/UpdateOpsItemCommand)la *Referencia AWS SDK para JavaScript de la API*.
# Ejemplos de Amazon Textract con el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de AWS SDK para JavaScript (v3) con Amazon Textract.
Los *escenarios* son ejemplos de código que muestran cómo llevar a cabo una tarea específica a través de llamadas a varias funciones dentro del servicio o combinado con otros Servicios de AWS.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Escenarios](#scenarios)
## Escenarios
### Creación de una aplicación de exploración de Amazon Textract
El siguiente ejemplo de código muestra cómo explorar la salida de Amazon Textract mediante una aplicación interactiva.
**SDK para JavaScript (v3)**
Muestra cómo utilizarla AWS SDK para JavaScript para crear una aplicación de React que utilice Amazon Textract para extraer datos de la imagen de un documento y mostrarlos en una página web interactiva. Este ejemplo se ejecuta en un navegador web y requiere una identidad autenticada de Amazon Cognito para las credenciales. Para el almacenamiento utiliza Amazon Simple Storage Service (Amazon S3) y para las notificaciones consulta una cola de Amazon Simple Queue Service (Amazon SQS) que está suscrita a un tema de Amazon Simple Notification Service (Amazon SNS).
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/textract-react).
**Servicios utilizados en este ejemplo**
+ Amazon Cognito Identity
+ Amazon S3
+ Amazon SNS
+ Amazon SQS
+ Amazon Textract
### Creación de una aplicación para analizar los comentarios de los clientes
El siguiente ejemplo de código muestra cómo crear una aplicación que analice las tarjetas de comentarios de los clientes, las traduzca del idioma original, determine sus opiniones y genere un archivo de audio a partir del texto traducido.
**SDK para JavaScript (v3)**
Esta aplicación de ejemplo analiza y almacena las tarjetas de comentarios de los clientes. Concretamente, satisface la necesidad de un hotel ficticio en la ciudad de Nueva York. El hotel recibe comentarios de los huéspedes en varios idiomas en forma de tarjetas de comentarios físicas. Esos comentarios se cargan en la aplicación a través de un cliente web. Una vez cargada la imagen de una tarjeta de comentarios, se llevan a cabo los siguientes pasos:
+ El texto se extrae de la imagen mediante Amazon Textract.
+ Amazon Comprehend determina la opinión del texto extraído y su idioma.
+ El texto extraído se traduce al inglés mediante Amazon Translate.
+ Amazon Polly sintetiza un archivo de audio a partir del texto extraído.
La aplicación completa se puede implementar con AWS CDK. Para obtener el código fuente y las instrucciones de implementación, consulte el proyecto en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/feedback-sentiment-analyzer). Los siguientes extractos muestran cómo AWS SDK para JavaScript se usa dentro de las funciones Lambda.
```
import {
ComprehendClient,
DetectDominantLanguageCommand,
DetectSentimentCommand,
} from "@aws-sdk/client-comprehend";
/**
* Determine the language and sentiment of the extracted text.
*
* @param {{ source_text: string}} extractTextOutput
*/
export const handler = async (extractTextOutput) => {
const comprehendClient = new ComprehendClient({});
const detectDominantLanguageCommand = new DetectDominantLanguageCommand({
Text: extractTextOutput.source_text,
});
// The source language is required for sentiment analysis and
// translation in the next step.
const { Languages } = await comprehendClient.send(
detectDominantLanguageCommand,
);
const languageCode = Languages[0].LanguageCode;
const detectSentimentCommand = new DetectSentimentCommand({
Text: extractTextOutput.source_text,
LanguageCode: languageCode,
});
const { Sentiment } = await comprehendClient.send(detectSentimentCommand);
return {
sentiment: Sentiment,
language_code: languageCode,
};
};
```
```
import {
DetectDocumentTextCommand,
TextractClient,
} from "@aws-sdk/client-textract";
/**
* Fetch the S3 object from the event and analyze it using Amazon Textract.
*
* @param {import("@types/aws-lambda").EventBridgeEvent<"Object Created">} eventBridgeS3Event
*/
export const handler = async (eventBridgeS3Event) => {
const textractClient = new TextractClient();
const detectDocumentTextCommand = new DetectDocumentTextCommand({
Document: {
S3Object: {
Bucket: eventBridgeS3Event.bucket,
Name: eventBridgeS3Event.object,
},
},
});
// Textract returns a list of blocks. A block can be a line, a page, word, etc.
// Each block also contains geometry of the detected text.
// For more information on the Block type, see https://docs.aws.amazon.com/textract/latest/dg/API_Block.html.
const { Blocks } = await textractClient.send(detectDocumentTextCommand);
// For the purpose of this example, we are only interested in words.
const extractedWords = Blocks.filter((b) => b.BlockType === "WORD").map(
(b) => b.Text,
);
return extractedWords.join(" ");
};
```
```
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
/**
* Synthesize an audio file from text.
*
* @param {{ bucket: string, translated_text: string, object: string}} sourceDestinationConfig
*/
export const handler = async (sourceDestinationConfig) => {
const pollyClient = new PollyClient({});
const synthesizeSpeechCommand = new SynthesizeSpeechCommand({
Engine: "neural",
Text: sourceDestinationConfig.translated_text,
VoiceId: "Ruth",
OutputFormat: "mp3",
});
const { AudioStream } = await pollyClient.send(synthesizeSpeechCommand);
const audioKey = `${sourceDestinationConfig.object}.mp3`;
// Store the audio file in S3.
const s3Client = new S3Client();
const upload = new Upload({
client: s3Client,
params: {
Bucket: sourceDestinationConfig.bucket,
Key: audioKey,
Body: AudioStream,
ContentType: "audio/mp3",
},
});
await upload.done();
return audioKey;
};
```
```
import {
TranslateClient,
TranslateTextCommand,
} from "@aws-sdk/client-translate";
/**
* Translate the extracted text to English.
*
* @param {{ extracted_text: string, source_language_code: string}} textAndSourceLanguage
*/
export const handler = async (textAndSourceLanguage) => {
const translateClient = new TranslateClient({});
const translateCommand = new TranslateTextCommand({
SourceLanguageCode: textAndSourceLanguage.source_language_code,
TargetLanguageCode: "en",
Text: textAndSourceLanguage.extracted_text,
});
const { TranslatedText } = await translateClient.send(translateCommand);
return { translated_text: TranslatedText };
};
```
**Servicios utilizados en este ejemplo**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate
# Ejemplos de Amazon Transcribe con el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de AWS SDK para JavaScript (v3) con Amazon Transcribe.
Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.
Los *escenarios* son ejemplos de código que muestran cómo llevar a cabo una tarea específica a través de llamadas a varias funciones dentro del servicio o combinado con otros Servicios de AWS.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Acciones](#actions)
+ [Escenarios](#scenarios)
## Acciones
### `DeleteMedicalTranscriptionJob`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteMedicalTranscriptionJob`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/transcribe#code-examples).
Cree el cliente.
```
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 };
```
Eliminar un trabajo de transcripción médica.
```
// 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 obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/transcribe-medical-examples-section.html#transcribe-delete-medical-job).
+ Para obtener más información sobre la API, consulta [DeleteMedicalTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/transcribe/command/DeleteMedicalTranscriptionJobCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `DeleteTranscriptionJob`
En el siguiente ejemplo de código, se muestra cómo utilizar `DeleteTranscriptionJob`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/transcribe#code-examples).
Eliminar un trabajo de transcripción.
```
// 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();
```
Cree el cliente.
```
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 };
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/transcribe-examples-section.html#transcribe-delete-job).
+ Para obtener más información sobre la API, consulta [DeleteTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/transcribe/command/DeleteTranscriptionJobCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListMedicalTranscriptionJobs`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListMedicalTranscriptionJobs`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/transcribe#code-examples).
Cree el cliente.
```
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 };
```
Enumerar trabajos de transcripción médica.
```
// 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 obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/transcribe-medical-examples-section.html#transcribe-list-medical-jobs).
+ Para obtener más información sobre la API, consulta [ListMedicalTranscriptionJobs](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/transcribe/command/ListMedicalTranscriptionJobsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `ListTranscriptionJobs`
En el siguiente ejemplo de código, se muestra cómo utilizar `ListTranscriptionJobs`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/transcribe#code-examples).
Enumerar trabajos de transcripción.
```
// 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();
```
Cree el cliente.
```
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 };
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/transcribe-examples-section.html#transcribe-list-jobs).
+ Para obtener más información sobre la API, consulta [ListTranscriptionJobs](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/transcribe/command/ListTranscriptionJobsCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `StartMedicalTranscriptionJob`
En el siguiente ejemplo de código, se muestra cómo utilizar `StartMedicalTranscriptionJob`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/transcribe#code-examples).
Cree el cliente.
```
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 };
```
Iniciar un trabajo de transcripción médica.
```
// 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 obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/transcribe-medical-examples-section.html#transcribe-start-medical-transcription).
+ Para obtener más información sobre la API, consulta [StartMedicalTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/transcribe/command/StartMedicalTranscriptionJobCommand)la *Referencia AWS SDK para JavaScript de la API*.
### `StartTranscriptionJob`
En el siguiente ejemplo de código, se muestra cómo utilizar `StartTranscriptionJob`.
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/transcribe#code-examples).
Iniciar un trabajo de transcripción.
```
// 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();
```
Cree el cliente.
```
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 };
```
+ Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/transcribe-examples-section.html#transcribe-start-transcription).
+ Para obtener más información sobre la API, consulta [StartTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/transcribe/command/StartTranscriptionJobCommand)la *Referencia AWS SDK para JavaScript de la API*.
## Escenarios
### Creación de una aplicación de streaming de Amazon Transcribe
El siguiente ejemplo de código muestra cómo crear una aplicación que grabe, transcriba y traduzca audio en directo en tiempo real para luego enviar por correo electrónico los resultados.
**SDK para JavaScript (v3)**
Muestra cómo utilizar Amazon Transcribe para crear una aplicación que grabe, transcriba y traduzca audio en directo en tiempo real para luego enviar los resultados por correo electrónico mediante Amazon Simple Email Service (Amazon SES).
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/transcribe-streaming-app).
**Servicios utilizados en este ejemplo**
+ Amazon Comprehend
+ Amazon SES
+ Amazon Transcribe
+ Amazon Translate
# Ejemplos de Amazon Translate con el SDK para JavaScript (v3)
Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el uso de AWS SDK para JavaScript (v3) con Amazon Translate.
Los *escenarios* son ejemplos de código que muestran cómo llevar a cabo una tarea específica a través de llamadas a varias funciones dentro del servicio o combinado con otros Servicios de AWS.
En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.
**Topics**
+ [Escenarios](#scenarios)
## Escenarios
### Creación de una aplicación de streaming de Amazon Transcribe
El siguiente ejemplo de código muestra cómo crear una aplicación que grabe, transcriba y traduzca audio en directo en tiempo real para luego enviar por correo electrónico los resultados.
**SDK para JavaScript (v3)**
Muestra cómo utilizar Amazon Transcribe para crear una aplicación que grabe, transcriba y traduzca audio en directo en tiempo real para luego enviar los resultados por correo electrónico mediante Amazon Simple Email Service (Amazon SES).
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/transcribe-streaming-app).
**Servicios utilizados en este ejemplo**
+ Amazon Comprehend
+ Amazon SES
+ Amazon Transcribe
+ Amazon Translate
### Crear un chatbot de Amazon Lex
En el siguiente ejemplo de código se muestra cómo crear un chatbot para atraer a visitantes a su sitio web.
**SDK para JavaScript (v3)**
Indica cómo utilizar la API de Amazon Lex para crear un Chatbot dentro de una aplicación web con el fin de atraer visitantes a su sitio web.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo sobre cómo [crear un chatbot Amazon Lex](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/lex-bot-example.html) en la guía para AWS SDK para JavaScript desarrolladores.
**Servicios utilizados en este ejemplo**
+ Amazon Comprehend
+ Amazon Lex
+ Amazon Translate
### Creación de una aplicación para analizar los comentarios de los clientes
El siguiente ejemplo de código muestra cómo crear una aplicación que analice las tarjetas de comentarios de los clientes, las traduzca del idioma original, determine sus opiniones y genere un archivo de audio a partir del texto traducido.
**SDK para JavaScript (v3)**
Esta aplicación de ejemplo analiza y almacena las tarjetas de comentarios de los clientes. Concretamente, satisface la necesidad de un hotel ficticio en la ciudad de Nueva York. El hotel recibe comentarios de los huéspedes en varios idiomas en forma de tarjetas de comentarios físicas. Esos comentarios se cargan en la aplicación a través de un cliente web. Una vez cargada la imagen de una tarjeta de comentarios, se llevan a cabo los siguientes pasos:
+ El texto se extrae de la imagen mediante Amazon Textract.
+ Amazon Comprehend determina la opinión del texto extraído y su idioma.
+ El texto extraído se traduce al inglés mediante Amazon Translate.
+ Amazon Polly sintetiza un archivo de audio a partir del texto extraído.
La aplicación completa se puede implementar con AWS CDK. Para obtener el código fuente y las instrucciones de implementación, consulte el proyecto en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/feedback-sentiment-analyzer). Los siguientes extractos muestran cómo AWS SDK para JavaScript se usa dentro de las funciones Lambda.
```
import {
ComprehendClient,
DetectDominantLanguageCommand,
DetectSentimentCommand,
} from "@aws-sdk/client-comprehend";
/**
* Determine the language and sentiment of the extracted text.
*
* @param {{ source_text: string}} extractTextOutput
*/
export const handler = async (extractTextOutput) => {
const comprehendClient = new ComprehendClient({});
const detectDominantLanguageCommand = new DetectDominantLanguageCommand({
Text: extractTextOutput.source_text,
});
// The source language is required for sentiment analysis and
// translation in the next step.
const { Languages } = await comprehendClient.send(
detectDominantLanguageCommand,
);
const languageCode = Languages[0].LanguageCode;
const detectSentimentCommand = new DetectSentimentCommand({
Text: extractTextOutput.source_text,
LanguageCode: languageCode,
});
const { Sentiment } = await comprehendClient.send(detectSentimentCommand);
return {
sentiment: Sentiment,
language_code: languageCode,
};
};
```
```
import {
DetectDocumentTextCommand,
TextractClient,
} from "@aws-sdk/client-textract";
/**
* Fetch the S3 object from the event and analyze it using Amazon Textract.
*
* @param {import("@types/aws-lambda").EventBridgeEvent<"Object Created">} eventBridgeS3Event
*/
export const handler = async (eventBridgeS3Event) => {
const textractClient = new TextractClient();
const detectDocumentTextCommand = new DetectDocumentTextCommand({
Document: {
S3Object: {
Bucket: eventBridgeS3Event.bucket,
Name: eventBridgeS3Event.object,
},
},
});
// Textract returns a list of blocks. A block can be a line, a page, word, etc.
// Each block also contains geometry of the detected text.
// For more information on the Block type, see https://docs.aws.amazon.com/textract/latest/dg/API_Block.html.
const { Blocks } = await textractClient.send(detectDocumentTextCommand);
// For the purpose of this example, we are only interested in words.
const extractedWords = Blocks.filter((b) => b.BlockType === "WORD").map(
(b) => b.Text,
);
return extractedWords.join(" ");
};
```
```
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
/**
* Synthesize an audio file from text.
*
* @param {{ bucket: string, translated_text: string, object: string}} sourceDestinationConfig
*/
export const handler = async (sourceDestinationConfig) => {
const pollyClient = new PollyClient({});
const synthesizeSpeechCommand = new SynthesizeSpeechCommand({
Engine: "neural",
Text: sourceDestinationConfig.translated_text,
VoiceId: "Ruth",
OutputFormat: "mp3",
});
const { AudioStream } = await pollyClient.send(synthesizeSpeechCommand);
const audioKey = `${sourceDestinationConfig.object}.mp3`;
// Store the audio file in S3.
const s3Client = new S3Client();
const upload = new Upload({
client: s3Client,
params: {
Bucket: sourceDestinationConfig.bucket,
Key: audioKey,
Body: AudioStream,
ContentType: "audio/mp3",
},
});
await upload.done();
return audioKey;
};
```
```
import {
TranslateClient,
TranslateTextCommand,
} from "@aws-sdk/client-translate";
/**
* Translate the extracted text to English.
*
* @param {{ extracted_text: string, source_language_code: string}} textAndSourceLanguage
*/
export const handler = async (textAndSourceLanguage) => {
const translateClient = new TranslateClient({});
const translateCommand = new TranslateTextCommand({
SourceLanguageCode: textAndSourceLanguage.source_language_code,
TargetLanguageCode: "en",
Text: textAndSourceLanguage.extracted_text,
});
const { TranslatedText } = await translateClient.send(translateCommand);
return { translated_text: TranslatedText };
};
```
**Servicios utilizados en este ejemplo**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate