Perguntas[amazon-web-services](server)

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?

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

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

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.

• Por que o centro de conhecimento da AWS sugere usar um balanceador de carga de rede para atribuir IP elástico ao serviço Fargate?
• Quais são as abordagens para adicionar um IP elástico estático ao meu serviço Fargate, sem usar um balanceador de carga?

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 :

Ouvinte e regras :

Ouvinte HTTPS:443

Regras:

APIs

• Condição : Caminho/some-path/api/*
• Ação : Encaminhar para o grupo alvo:
  • api-nó-0 (33,33%)
  • api-nó-1 (33,33%)
  • api-nó-2 (33,33%)
  • Adesividade: Desligado

soquete da web

• Condição : Caminho/some-path/websocket/*
• Ação : Encaminhar para o grupo alvo:
  • websocket-nó-0 (33,33%)
  • websocket-nó-1 (33,33%)
  • websocket-nó-2 (33,33%)
  • Adesividade: Desligado

padrão

• Condição : Nenhuma outra regra se aplica
• Ação : Encaminhar para o grupo alvo:
  • api-nó-0 (100%)

Atributos da verificação de integridade :

• Intervalo: 30 segundos
• Tempo limite: 5 segundos
• Limiar saudável: 2
• Limiar insalubre: 2
• Limiar saudável: 2 sucessos consecutivos em testes de saúde
• Limite não saudável: 2 falhas consecutivas na verificação de integridade
• Códigos de sucesso: 200

Atributos do balanceador de carga :

• Duração de keepalive do cliente HTTP: 3600 segundos
• Tempo limite de conexão ociosa: 60 segundos
• Cabeçalho X-Forwarded-For: Acrescentar
• Balanceamento de carga entre zonas: Ativado

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 .

Estou tendo algumas dificuldades para fazer algumas coisas funcionarem com cópias de dados entre contas. Especificamente, estou tentando clonar um bucket S3 de uma conta AWS (em eu-west-1) para outra (em eu-west-2).

Tentei configurar a replicação de bucket conforme este guia , adicionando uma Operação em Lote de Replicação para copiar arquivos existentes e também tentei um trabalho DataSync conforme este guia .

Apesar de ter seguido os guias à risca:

• As métricas de replicação não mostram nenhuma atividade e o bucket de destino ainda está vazio 24 horas depois.

• A operação em lote de replicação foi abortada pelo motivo Job failure rate 100% is above 50%.

• O log do CloudWatch para o trabalho do DataSync fornece apenas este detalhe:finished with status Unable to connect to S3 endpoint

Gostaria de saber se estou esquecendo de algum pré-requisito que os guias assumem que já terá sido configurado; por exemplo: há necessidade de estabelecer algum tipo de relação de confiança entre duas contas da AWS antes que as permissões entre contas funcionem?

ou seja, onde o bucket S3 de destino pretendido na conta 987654321098 tem uma política de permissões que inclui este snippet para identificar a função de ação na conta de origem:

        "Sid": "DataSyncCreateS3LocationAndTaskAccess",
        "Effect": "Allow",
        "Principal": { "AWS": "arn:aws:iam::123456789012:role/source-account-datasync-s3-copy-role" }

...isso é tudo o que é necessário para que a conta de destino confie na função do IAM da outra conta?

Para instâncias do AWS EC2 e Aliyun ou outros serviços de computação em nuvem semelhantes, há garantia de que a VM será executada na mesma máquina física sempre que você a iniciar ou ela pode migrar de uma máquina física para outra?

Também sei que os hipervisores oferecem suporte à migração ao vivo, então é possível que minha instância aws/aliyun em execução tenha sido migrada pelo provedor de serviços, o que pode causar uma interrupção de curto prazo ou falta de resposta.

Aqui está o motivo da minha pergunta: Tenho um servidor aliyun coletando fluxos de pacotes de dados em tempo real de outro servidor aws. Cada pacote tem uma tag de carimbo de data/hora do remetente. No lado do receptor, o receptor usa (current_local_timestamp - sender_timestamp) para obter o tempo decorrido. Normalmente, esse tempo decorrido é de cerca de 30 a 50 ms, às vezes ~ 100 ms. Mas, em casos extremos, esse tempo decorrido pode ir até alguns segundos ou até mais de 1 minuto, esse caso acontece pelo menos 2 a 3 vezes por mês, geralmente na sexta-feira (mas nem sempre) ou em alguns feriados.

Estou tentando descobrir o motivo do atraso extremamente grande no transporte.