Reduzi meu problema ao seguinte exemplo. Temos dois tipos de requisições XML: <data1>some-data</data1>e <data2>other-data</data2>chegando ao mesmo endpoint com algo como POST https://example.com/my-endpoint. Queremos servir data1com AWS Lambda Node.js e data2com AWS EC2 Apache + PHP. Como isso é possível?
Isto é um complemento à pergunta feita aqui: migração do GCP para a AWS Hosted Zone
Exportei os registros DNS do GCP e os importei para a AWS. Também mantive as entradas no GCP para garantir que quaisquer solicitações que cheguem ao GCP Clod DNS ainda sejam resolvidas. Atualizei meu registrador DNS para apontar os registros NS para a AWS. No entanto, após essa alteração, alguns de nossos usuários não conseguem acessar nossos servidores. Muitos de nossos usuários conseguem acessar os servidores, mas falha para alguns deles. Qual pode ser o motivo?
a) Devo dar algum intervalo de tempo após importar os registros na AWS antes de alterar as entradas no registrador?
b) Existe uma maneira segura de verificar se a propagação do DNS está completa? Eu verifiquei usando https://www.whatsmydns.net/ e pude ver que todos os servidores de nomes do mundo conseguiram resolver meu domínio. Mas como alguns de nossos usuários reclamaram, tive que reverter as alterações feitas no meu registrador.
Qualquer dica seria bem-vinda.
Alguns certificados da AWS têm este emissor:
issuer=C=US, O=Amazon, CN=Amazon RSA 2048 M02
Outros têm isto:
issuer=C=US, O=Amazon, CN=Amazon RSA 2048 M03
Qual é a diferença entre eles?
Temos um web-service, o(s) frontend(s) para o qual é dividido em vários aplicativos que são entregues por endpoints cloudfront. Atualmente, todos eles têm seus próprios subdomínios, como, por exemplo, service-a.mydomain.com, service-b.mydomain.com, etc.
No entanto, subdomínios quase não têm impacto em como o Google estabelece autoridade de domínio atualmente, e a autoridade de domínio se tornou o Santo Graal do SEO. Então, para fins de otimização de mecanismos de busca, queremos mover tudo para um caminho em um domínio de nível superior. Então, depois, deve ser meudominio.com/serviço-a, meudominio.com/serviço-b etc.
Obviamente, isso parece exigir um proxy, como um gateway de API ou algo assim, para rotear tudo. O problema com isso é... bem, se tudo passa pelo mesmo proxy, então as principais vantagens do cloudfront (ou qualquer outro CDN) praticamente vão por água abaixo. Claro que você pode executá-lo por trás do proxy, mas tudo o que você tem então é um cache. Adeus, edge locations. Nesse ponto, faria mais sentido ter o cache no próprio proxy, realmente.
Então, minha pergunta é: ainda há alguma maneira de usar os locais de borda do cloudfront se eu não puder dar a cada ponto final seu próprio subdomínio? Ou essa forma de design de domínio simplesmente requer abandonar as vantagens de uma CDN?
Tenho um cluster ECS (no Fargate 1.4.0) com muitas tarefas e serviços que fazem login no Cloudwatch, e está tudo bem. Tenho algumas tarefas agendadas do ECS (via EventBridge), e sei que elas estão sendo executadas no horário agendado, conforme o esperado. Sei disso porque a) posso vê-las na guia EventBridge Rule monitoring, e b) uma das tarefas agendadas é enviar um e-mail, e eu recebo esse e-mail. Então, ele está sendo executado, mas não faz login no CloudWatch como as outras tarefas?
Antes de prosseguir com as etapas de solução de problemas, deixe-me dar mais informações:
Em cada definição de tarefa, tenho este bloco de log:
logConfiguration = {
logDriver = "awslogs"
options = {
awslogs-group = aws_cloudwatch_log_group.ecs_log_group.name
awslogs-region = "us-east-1"
awslogs-stream-prefix = "prod-cron-engage"
}
}
Sei que tudo está correto lá porque minhas outras tarefas que não estão agendadas (executadas por meio de serviços 24 horas por dia, 7 dias por semana) estão sendo registradas com sucesso lá.
Cada tarefa tem estes dois parâmetros:
execution_role_arn = aws_iam_role.ecs_task_execution_role.arn
task_role_arn = aws_iam_role.ecs_task_execution_role.arn
Estes são:
resource "aws_iam_role" "ecs_task_execution_role" {
name = "ecsTaskExecutionRole"
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [
{
Action = "sts:AssumeRole"
Effect = "Allow"
Principal = {
Service = "ecs-tasks.amazonaws.com"
}
}
]
})
tags = {
"Name" = "${var.name_prefix}-iam-ecs-role"
}
}
resource "aws_iam_role_policy_attachment" "ecs_task_execution_role_policy" {
role = aws_iam_role.ecs_task_execution_role.name
policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
}
No AmazonECSTaskExecutionRolePolicy, há políticas essenciais para o ECS, incluindo acesso ao CloudWatch.
Além disso, aqui está minha regra de ponte de eventos:
resource "aws_cloudwatch_event_rule" "prod_cron_engage_rule" {
name = "prod-engage-rule"
description = "Run Prod Engage task every 30 minutes."
schedule_expression = "rate(30 minutes)"
}
resource "aws_cloudwatch_event_target" "prod_cron_engage_target" {
target_id = "run-prod-engage-task-every-half-an-hour"
rule = aws_cloudwatch_event_rule.prod_cron_engage_rule.name
arn = aws_ecs_cluster.ecs_cluster.arn
role_arn = aws_iam_role.eventbridge_role.arn
ecs_target {
task_definition_arn = aws_ecs_task_definition.prod_cron_engage_task.arn
task_count = 1
launch_type = "FARGATE"
network_configuration {
subnets = module.vpc.private_subnets
security_groups = [aws_security_group.ecs_sg.id]
assign_public_ip = false
}
tags = {
"Name" = "${var.name_prefix}-ecs-prod-cron-engage"
}
}
}
Aqui estão as funções e políticas do EventBridge:
resource "aws_iam_role" "eventbridge_role" {
name = "eventbridge-ecs-role"
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [
{
Action = "sts:AssumeRole"
Principal = {
Service = "events.amazonaws.com"
}
Effect = "Allow"
Sid = ""
}
]
})
}
resource "aws_iam_role_policy" "eventbridge_policy" {
name = "eventbridge-ecs-policy"
role = aws_iam_role.eventbridge_role.id
policy = jsonencode({
Version = "2012-10-17"
Statement = [
{
Action = "ecs:RunTask"
Effect = "Allow"
Resource = [
aws_ecs_task_definition.prod_cron_engage_task.arn
]
},
{
Action = "iam:PassRole"
Effect = "Allow"
Resource = aws_iam_role.eventbridge_role.arn
}
]
})
}
O que eu fiz até agora?
No começo, pensei que talvez, de alguma forma, houvesse uma regra de restrição que negasse o acesso dessas tarefas agendadas ao CloudWatch (improvável, mas pensei que, já que agora elas estão agendadas com o EventBridge, talvez seja possível), então dou ao ECS e ao EventBridge acesso total ao CloudWatch. Não muda nada.
Tentei criar um novo grupo de logs com essas permissões amplas e ver se as tarefas podem criar esse novo grupo de logs ou não. O novo grupo de logs não estava lá, então os grupos de logs não puderam ser criados por meio de definições de tarefas.
Este erro aparece em um arquivo de log (levemente formatado para facilitar a leitura):
StatusCode: 400 : Bad Request : {
schema :[ urn:ietf:params:scim:api:messages:2.0:Error ]
schemas :[ urn:ietf:params:scim:api:messages:2.0:Error ]
detail : 1 validation error detected:
Value at 'phoneNumbers.1.value' failed to satisfy constraint:
Member must satisfy regular expression pattern:
[\\p{L}\\p{M}\\p{S}\\p{N}\\p{P}\\t\\n\\r ]+
}
É provável que isso ocorra devido a um número de telefone neste formato:
+1 (212) 555-1212
Em vez de um destes formatos:
12125551212
+1.212.555.1212
Como interpretar essa regex para confirmar isso?
Quero adicionar um IP estático ao meu serviço ECS Fargate. Atualmente, consigo configurar o Elastic IP com um Network Load Balancer, mas não quero adicionar nenhum load balancer.
Tenho um grupo de escala (ASG) que uso para manter instâncias prontas para uma tarefa. A instância é separada do ASG quando necessário e o ASG inicia outra instância quando necessário.
O tipo de instância é c6g.4xlarge. O SO é ubuntu 22.04
Abaixo está o log mostrando o tempo de inicialização.
systemd[1]: Startup finished in 4.850s (kernel) + 42min 16.004s (userspace) = 42min 20.854s.
Posso ver vários desses logs SSM com falha
ERROR [Registrar] failed to register identity: error calling RegisterManagedInstance API: RequestError: send request failed
caused by: Post "https://ssm.us-xxxx-x.amazonaws.com/": dial tcp xx.xx.xx.xx:xx: i/o timeout
INFO [Registrar] sleeping for 18.7 minutes before retrying registration
Isso acontece apenas em uma pequena porcentagem de casos e não consigo descobrir um padrão.
Tenho um aplicativo e estou usando AWS para ele. Tenho duas instâncias. Uma está parada e uma está em execução. Cada instância tem um volume anexado. Gostaria de encerrar a instância parada, mas quero ter certeza de que isso não afetará o aplicativo. Minha suposição é que a instância parada não afetaria o aplicativo, pois ele está parado.
Não fiz nada até agora porque não quero estragar o aplicativo.
Tenho 3 instâncias ( node-0, node-1, node-2) executando 2 serviços - um é a websockete o outro é an API(ambos os serviços são executados em cada instância).
Configuração do grupo-alvo :
| Grupo alvo | Exemplo | Caminho de verificação de saúde |
|---|---|---|
| api-nó-0 | nó-0 | /algum-caminho/api/v1/ping |
| api-nó-1 | nó-1 | /algum-caminho/api/v1/ping |
| api-nó-2 | nó-2 | /algum-caminho/api/v1/ping |
| websocket-nó-0 | nó-0 | /algum-caminho/websocket/v1/ping |
| websocket-nó-1 | nó-1 | /algum-caminho/websocket/v1/ping |
| websocket-nó-2 | nó-2 | /algum-caminho/websocket/v1/ping |
Ouvinte e regras :
Ouvinte HTTPS:443
Regras:
/some-path/api/*/some-path/websocket/*Atributos da verificação de integridade :
Atributos do balanceador de carga :
PS Se precisar de mais informações sobre a configuração, avise-me.
Durante o teste normal, onde todos os grupos de destino estão saudáveis, o ALB parece estar operando conforme o esperado. O problema surge quando eu quero simular um cenário em que um dos serviços em um nó se torna insalubre, eu alterei o caminho de verificação de integridade do IE api-node-1, ele aparece como insalubre ( Error 404), mas o tráfego ainda está sendo enviado para ele. Confirmado por meio de logs de acesso e métricas do CloudWatch ( RequestCountPerTarget). Eu também tentei, como uma simulação de um grupo insalubre, bloquear o acesso do ALB removendo o grupo de segurança relevante da instância. ( Error 400)
Métodos de teste (com grupo-alvo não íntegro): usando curl (10 a 20 vezes) ou um teste de carga Grafana k6 e tráfego monitorado nos Logs de acesso e no Cloudwatch - o tráfego ainda estava sendo roteado para todas as instâncias e uma delas foi mostrada como não íntegra.
Você pode encontrar outra pergunta que discutiu esse assunto aqui .