# Invocar uma função do Lambda com um procedimento armazenado do Aurora MySQL (defasado)
Você pode invocar uma função do AWS Lambda a partir de um cluster de banco de dados Aurora MySQL chamando o procedimento `mysql.lambda_async`. Essa abordagem pode ser útil quando você desejar integrar o banco de dados em execução no Aurora MySQL a outros produtos da AWS. Por exemplo, você pode querer enviar uma notificação usando o Amazon Simple Notification Service (Amazon SNS) sempre que uma linha for inserida em uma tabela específica no seu banco de dados.
**Contents**
+ [Considerações da versão do Aurora MySQL](#AuroraMySQL.Integrating.ProcLambda.caveats)
+ [Trabalhar com o procedimento mysql.lambda\$1async para invocar uma função do Lambda (defasado)](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async)
+ [Sintaxe](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Syntax)
+ [Parâmetros](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Parameters)
+ [Exemplos](#AuroraMySQL.Integrating.Lambda.mysql_lambda_async.Examples)
## Considerações da versão do Aurora MySQL
A partir do Aurora MySQL versão 2, é possível usar o método da função nativa em vez desses procedimentos armazenados para invocar uma função do Lambda. Para obter mais informações sobre as funções nativas, consulte [Como trabalhar com funções nativas para uma função do Lambda](AuroraMySQL.Integrating.NativeLambda.md#AuroraMySQL.Integrating.NativeLambda.lambda_functions).
No Aurora MySQL versão 2, o procedimento armazenado `mysql.lambda_async` não é mais compatível. Em vez disso, é altamente recomendável o uso de funções nativas do Lambda.
No Aurora MySQL versão 3, o procedimento armazenado não está disponível.
## Trabalhar com o procedimento mysql.lambda\$1async para invocar uma função do Lambda (defasado)
O procedimento `mysql.lambda_async` é um procedimento armazenado interno que invoca uma função do Lambda de forma assíncrona. Para usar esse procedimento, o usuário do banco de dados deve ter privilégios `EXECUTE` no procedimento armazenado `mysql.lambda_async`.
### Sintaxe
O procedimento `mysql.lambda_async` tem a seguinte sintaxe.
```
CALL mysql.lambda_async (
lambda_function_ARN,
lambda_function_input
)
```
### Parâmetros
O procedimento `mysql.lambda_async` tem os seguintes parâmetros.
* lambda\$1function\$1ARN *
O nome de recurso da Amazon (ARN) da função Lambda a ser invocada.
* lambda\$1function\$1input *
A string de entrada, no formato JSON, para a função Lambda invocada.
### Exemplos
Como melhores práticas, recomendamos que você faça chamadas do procedimento `mysql.lambda_async` em um procedimento armazenado que possa ser chamado de diferentes origens, como disparadores ou código de cliente. Essa abordagem pode ajudar a evitar problemas de incompatibilidade de impedância e facilitar a invocação de funções Lambda.
**nota**
Tenha cuidado ao invocar uma função do AWS Lambda de triggers em tabelas que apresentam alto tráfego de gravação. Os triggers `INSERT`, `UPDATE` e `DELETE` são ativados por linha. Uma workload com muitas gravações em uma tabela com triggers `INSERT`, `UPDATE` ou `DELETE` resulta em um grande número de chamadas para a sua função do AWS Lambda.
Embora as chamadas para o procedimento `mysql.lambda_async` sejam assíncronas, os triggers são síncronos. Uma instrução que resulta em um grande número de ativações de triggers não aguarda a conclusão da chamada para a função do AWS Lambda, mas aguarda a conclusão dos triggers antes de retornar o controle ao cliente.
**Example Exemplo: invocar uma função do AWS Lambda para enviar e-mail**
O exemplo a seguir cria um procedimento armazenado que você pode chamar no seu código de banco de dados para enviar um e-mail usando uma função Lambda.
**AWS Lambda Função do**
```
import boto3
ses = boto3.client('ses')
def SES_send_email(event, context):
return ses.send_email(
Source=event['email_from'],
Destination={
'ToAddresses': [
event['email_to'],
]
},
Message={
'Subject': {
'Data': event['email_subject']
},
'Body': {
'Text': {
'Data': event['email_body']
}
}
}
)
```
**Procedimento armazenado**
```
DROP PROCEDURE IF EXISTS SES_send_email;
DELIMITER ;;
CREATE PROCEDURE SES_send_email(IN email_from VARCHAR(255),
IN email_to VARCHAR(255),
IN subject VARCHAR(255),
IN body TEXT) LANGUAGE SQL
BEGIN
CALL mysql.lambda_async(
'arn:aws:lambda:us-west-2:123456789012:function:SES_send_email',
CONCAT('{"email_to" : "', email_to,
'", "email_from" : "', email_from,
'", "email_subject" : "', subject,
'", "email_body" : "', body, '"}')
);
END
;;
DELIMITER ;
```
**Chamar o procedimento armazenado para invocar a função do AWS Lambda**
```
mysql> call SES_send_email('example_from@amazon.com', 'example_to@amazon.com', 'Email subject', 'Email content');
```
**Example Exemplo: invocar uma função do AWS Lambda para publicar um evento a partir de um trigger**
O exemplo a seguir cria um procedimento armazenado que publica um evento usando o Amazon SNS. O código chama o procedimento de um trigger quando uma linha é adicionada a uma tabela.
**AWS Lambda Função do**
```
import boto3
sns = boto3.client('sns')
def SNS_publish_message(event, context):
return sns.publish(
TopicArn='arn:aws:sns:us-west-2:123456789012:Sample_Topic',
Message=event['message'],
Subject=event['subject'],
MessageStructure='string'
)
```
**Procedimento armazenado**
```
DROP PROCEDURE IF EXISTS SNS_Publish_Message;
DELIMITER ;;
CREATE PROCEDURE SNS_Publish_Message (IN subject VARCHAR(255),
IN message TEXT) LANGUAGE SQL
BEGIN
CALL mysql.lambda_async('arn:aws:lambda:us-west-2:123456789012:function:SNS_publish_message',
CONCAT('{ "subject" : "', subject,
'", "message" : "', message, '" }')
);
END
;;
DELIMITER ;
```
**Tabela**
```
CREATE TABLE 'Customer_Feedback' (
'id' int(11) NOT NULL AUTO_INCREMENT,
'customer_name' varchar(255) NOT NULL,
'customer_feedback' varchar(1024) NOT NULL,
PRIMARY KEY ('id')
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
**Trigger**
```
DELIMITER ;;
CREATE TRIGGER TR_Customer_Feedback_AI
AFTER INSERT ON Customer_Feedback
FOR EACH ROW
BEGIN
SELECT CONCAT('New customer feedback from ', NEW.customer_name), NEW.customer_feedback INTO @subject, @feedback;
CALL SNS_Publish_Message(@subject, @feedback);
END
;;
DELIMITER ;
```
**Inserir uma linha na tabela para disparar a notificação**
```
mysql> insert into Customer_Feedback (customer_name, customer_feedback) VALUES ('Sample Customer', 'Good job guys!');
```