A pesquisa de resultados CAPTCHA vincula os threads e cria um acoplamento forte entre o raspador e o pipeline de resolução. O AWS SNS (Simple Notification Service) dissocia essas preocupações: CaptchaAI envia resultados para seu retorno de chamada, que os publica no SNS, e qualquer número de consumidores downstream reage de forma independente.
Visão geral da arquitetura
[Scraper] → Submit CAPTCHA → [CaptchaAI API]
↓
Solve completes
↓
Callback → [API Gateway + Lambda]
↓
Publish → [SNS Topic]
↓
┌───────────────┼───────────────┐
↓ ↓ ↓
[SQS Queue] [Lambda Logger] [Email Alert]
(result store) (audit trail) (on failure)
O SNS fornece distribuição: um resultado CAPTCHA aciona vários consumidores sem que o manipulador de retorno de chamada saiba sobre eles.
Etapa 1: crie o tópico SNS
CLI da AWS
aws sns create-topic --name captcha-results --output text
# Returns: arn:aws:sns:us-east-1:123456789:captcha-results
Python (boto3)
import boto3
sns = boto3.client("sns", region_name="us-east-1")
response = sns.create_topic(Name="captcha-results")
topic_arn = response["TopicArn"]
print(f"Topic ARN: {topic_arn}")
Etapa 2: construir o receptor de retorno de chamada
Esta função Lambda recebe resultados de retorno de chamada CaptchaAI e os publica no SNS.
Python (manipulador Lambda)
import json
import os
import boto3
sns = boto3.client("sns")
TOPIC_ARN = os.environ["SNS_TOPIC_ARN"]
def lambda_handler(event, context):
"""Receive CaptchaAI callback and publish to SNS."""
# Parse query parameters from API Gateway
params = event.get("queryStringParameters", {}) or {}
task_id = params.get("id", "")
solution = params.get("code", "")
if not task_id or not solution:
return {"statusCode": 400, "body": "Missing id or code"}
# Publish to SNS
message = {
"task_id": task_id,
"solution": solution,
"status": "solved"
}
sns.publish(
TopicArn=TOPIC_ARN,
Message=json.dumps(message),
Subject="captcha-solved",
MessageAttributes={
"task_id": {
"DataType": "String",
"StringValue": task_id
}
}
)
return {"statusCode": 200, "body": "OK"}
JavaScript (manipulador Lambda)
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");
const sns = new SNSClient({ region: "us-east-1" });
const TOPIC_ARN = process.env.SNS_TOPIC_ARN;
exports.handler = async (event) => {
const params = event.queryStringParameters || {};
const taskId = params.id;
const solution = params.code;
if (!taskId || !solution) {
return { statusCode: 400, body: "Missing id or code" };
}
const message = {
task_id: taskId,
solution: solution,
status: "solved",
};
await sns.send(
new PublishCommand({
TopicArn: TOPIC_ARN,
Message: JSON.stringify(message),
Subject: "captcha-solved",
MessageAttributes: {
task_id: { DataType: "String", StringValue: taskId },
},
})
);
return { statusCode: 200, body: "OK" };
};
Etapa 3: enviar CAPTCHAs com o URL de retorno de chamada
Aponte pingback de CaptchaAI para o endpoint do API Gateway:
Pitão
import os
import requests
API_KEY = os.environ["CAPTCHAAI_API_KEY"]
CALLBACK_URL = os.environ["CALLBACK_GATEWAY_URL"] # API Gateway URL
def submit_captcha(sitekey, pageurl):
"""Submit CAPTCHA with SNS-backed callback."""
resp = requests.post("https://ocr.captchaai.com/in.php", data={
"key": API_KEY,
"method": "userrecaptcha",
"googlekey": sitekey,
"pageurl": pageurl,
"pingback": CALLBACK_URL,
"json": 1
})
data = resp.json()
if data.get("status") == 1:
return data["request"] # task_id
raise RuntimeError(f"Submit failed: {data.get('request')}")
Etapa 4: inscrever consumidores
Fila SQS (armazenamento de resultados)
# Subscribe an SQS queue to receive all results
sqs_arn = "arn:aws:sqs:us-east-1:123456789:captcha-results-queue"
sns.subscribe(
TopicArn=topic_arn,
Protocol="sqs",
Endpoint=sqs_arn
)
Lambda (registrador de auditoria)
# Subscribe a Lambda for audit logging
lambda_arn = "arn:aws:lambda:us-east-1:123456789:function:captcha-audit-logger"
sns.subscribe(
TopicArn=topic_arn,
Protocol="lambda",
Endpoint=lambda_arn
)
E-mail (alertas de falha)
# Subscribe email for error notifications with filter
sns.subscribe(
TopicArn=topic_arn,
Protocol="email",
Endpoint="ops@example.com"
)
Etapa 5: consumir resultados do SQS
Seu raspador lê soluções do SQS em vez de pesquisar CaptchaAI:
Pitão
import json
import boto3
sqs = boto3.client("sqs", region_name="us-east-1")
QUEUE_URL = os.environ["SQS_QUEUE_URL"]
def get_solved_captcha(timeout=30):
"""Wait for a CAPTCHA solution from the SQS queue."""
response = sqs.receive_message(
QueueUrl=QUEUE_URL,
MaxNumberOfMessages=1,
WaitTimeSeconds=min(timeout, 20) # Long polling (max 20s)
)
messages = response.get("Messages", [])
if not messages:
return None
msg = messages[0]
# SNS wraps the message — unwrap it
sns_envelope = json.loads(msg["Body"])
result = json.loads(sns_envelope["Message"])
# Delete message after processing
sqs.delete_message(
QueueUrl=QUEUE_URL,
ReceiptHandle=msg["ReceiptHandle"]
)
return result
JavaScript
const {
SQSClient,
ReceiveMessageCommand,
DeleteMessageCommand,
} = require("@aws-sdk/client-sqs");
const sqs = new SQSClient({ region: "us-east-1" });
const QUEUE_URL = process.env.SQS_QUEUE_URL;
async function getSolvedCaptcha(timeout = 30) {
const response = await sqs.send(
new ReceiveMessageCommand({
QueueUrl: QUEUE_URL,
MaxNumberOfMessages: 1,
WaitTimeSeconds: Math.min(timeout, 20),
})
);
const messages = response.Messages || [];
if (messages.length === 0) return null;
const msg = messages[0];
const snsEnvelope = JSON.parse(msg.Body);
const result = JSON.parse(snsEnvelope.Message);
await sqs.send(
new DeleteMessageCommand({
QueueUrl: QUEUE_URL,
ReceiptHandle: msg.ReceiptHandle,
})
);
return result;
}
Filtragem de mensagens SNS
Encaminhe resultados diferentes para consumidores diferentes:
# Only send failures to the ops queue
sns.subscribe(
TopicArn=topic_arn,
Protocol="sqs",
Endpoint=failure_queue_arn,
Attributes={
"FilterPolicy": json.dumps({
"status": ["failed", "error"]
})
}
)
Solução de problemas
| Problema | Causa | Correção |
|---|---|---|
| Retorno de chamada retorna 403 | Bloqueio de autenticação do API Gateway CaptchaAI | Desative a autenticação na rota de retorno de chamada; use validação baseada em token |
| Mensagens SQS não chegam | Permissão SNS → SQS ausente | Adicionar permissão sns:Publish à política de fila SQS |
| Resultados duplicados processados | SNS entrega pelo menos uma vez | Implemente idempotência – verifique task_id antes de processar |
| Lambda cold start atrasa retorno de chamada | Simultaneidade provisionada não definida | Habilite a simultaneidade provisionada para o callback Lambda |
Perguntas frequentes
Por que usar o SNS em vez de processar os resultados diretamente no callback Lambda?
O SNS desacopla o manipulador de retorno de chamada da lógica downstream. Você pode adicionar novos consumidores (registro, alertas, análises) sem modificar o retorno de chamada do Lambda. O retorno de chamada permanece simples e rápido.
Qual é a latência adicionada da camada SNS?
O SNS adiciona 10 a 50 ms por mensagem. Como a resolução do CAPTCHA leva de 5 a 30 segundos, essa sobrecarga é insignificante.
Posso usar SNS FIFO para processamento de pedidos?
Sim. Use um tópico SNS FIFO com fila SQS FIFO se precisar de resultados ordenados. Defina MessageGroupId como o ID da tarefa para ordenação por tarefa.
Artigos relacionados
- Construindo pipelines de Captcha do cliente Captchaai
- Construindo Captchaai de Automação Responsável
- Construindo monitoramento do painel de uso do Captchaai
Próximas etapas
Crie soluções CAPTCHA orientadas a eventos -obtenha sua chave API CaptchaAIe conecte-o ao pipeline de eventos da AWS.
Guias relacionados:
- Integração sem servidor AWS Lambda + CaptchaAI
- URL de retorno de chamada e guia de webhook
- Segurança do Webhook: Validando retornos de chamada
