# Relógio de precisão e sincronização de horas em sua instância do EC2
Uma referência de horário consistente e precisa na instância do Amazon EC2 é crucial para muitas tarefas e processos de servidor. Os timestamps nos logs do sistema desempenham um papel essencial na identificação de quando os problemas ocorreram e na ordem cronológica dos eventos. Se você usar a AWS CLI ou um SDK da AWS para fazer solicitações à instância, essas ferramentas assinarão as solicitações em seu nome. Se as configurações de data e hora da instância não forem exatas, poderá haver uma discrepância entre a data na assinatura e a data da solicitação, levando a AWS a rejeitar suas solicitações.
Para lidar com esse aspecto importante, a Amazon oferece o Serviço de Sincronização Temporal da Amazon, que é acessível em todas as instâncias do EC2 e é usado por vários Serviços da AWS. Esse serviço usa uma frota de relógios de referência atômicos e conectados via satélite em cada Região da AWS para fornecer leituras de hora exatas e atuais do padrão global do Horário Universal Coordenado (UTC).
Para obter a melhor performance, recomendamos o uso do [Serviço de Sincronização Temporal da Amazon](configure-ec2-ntp.md) local nas instâncias do EC2. Para fazer backup no Serviço de Sincronização Temporal da Amazon local nas instâncias ou para conectar ao Serviço de Sincronização Temporal da Amazon recursos externos ao Amazon EC2, você pode usar o [Serviço de Sincronização Temporal da Amazon](configure-time-sync.md) público localizado em `time.aws.com`. O Serviço de Sincronização Temporal da Amazon público, como o Serviço de Sincronização Temporal da Amazon local, faz automaticamente a difusão de qualquer segundo bissexto adicionado ao UTC. O Serviço de Sincronização Temporal da Amazon público é compatível globalmente com nossa frota de relógios atômicos de referência conectados via satélite em cada Região da AWS.
## Carimbo de data e hora de pacotes de hardware
É possível habilitar o carimbo de data e hora de pacotes de hardware na instância para adicionar um carimbo de data e hora de precisão de 64 bits em nanossegundos a cada pacote de rede recebido. Como o carimbo de data e hora de pacotes de hardware ocorre no nível do hardware (antes que o pacote atinja o kernel, o socket ou a camada da aplicação), você evita atrasos adicionados pelo carimbo de data e hora de software. O relógio de referência subjacente do carimbo de data e hora de hardware é o [relógio de hardware PTP](configure-ec2-ntp.md#connect-to-the-ptp-hardware-clock) do Amazon Time Sync Service.
**Benefícios**
O carimbo de data e hora de pacotes de hardware oferece os seguintes benefícios:
+ Melhora a ordenação de eventos, que também pode ser usada para determinar a ordem real em que os pacotes chegam à instância do EC2, garantindo um processamento correto dos pacotes.
+ Mede a latência unidirecional da rede.
+ Aumenta a velocidade das transações distribuídas com maior precisão e exatidão em comparação com a maioria das soluções on-premises.
**Pré-requisitos e configuração**
Para habilitar o carimbo de data e hora de pacotes de hardware, sua instância deve atender aos seguintes pré-requisitos:
+ Deve ser uma instância Linux.
+ Atender aos [requisitos para suporte ao relógio de hardware PTP](configure-ec2-ntp.md#ptp-hardware-clock-requirements).
Para conhecer as instruções de configuração, consulte o tópico [Hardware Packet Timestamping](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#hardware-packet-timestamping) na página **Linux kernel driver for Elastic Network Adapter (ENA) family** no *GitHub*.
## Segundos bissextos
Os segundos bissextos, introduzidos em 1972, são ajustes ocasionais de um segundo no horário UTC para considerar as irregularidades na rotação da Terra, a fim de acomodar as diferenças entre o Tempo Atômico Internacional (TAI) e o horário solar (Ut1). Para gerenciar os segundos bissextos para os clientes, criamos a difusão de segundos bissextos no Serviço de Sincronização Temporal da Amazon. Para obter mais informações, consulte [Look Before You Leap — The Coming Leap Second and AWS](https://aws.amazon.com/blogs/aws/look-before-you-leap-the-coming-leap-second-and-aws/).
Os segundos bissextos vão acabar e apoiamos totalmente a decisão tomada na [27ª Conferência Geral sobre Pesos e Medidas de abandonar os segundos bissextos até 2035](https://www.bipm.org/en/cgpm-2022/resolution-4).
Para apoiar essa transição, ainda planejamos continuar a aplicar a difusão durante um evento de segundos bissextos ao acessar o Serviço de Sincronização Temporal da Amazon via conexão NTP local ou nossos consultas de NTP público (`time.aws.com`). O relógio PTP físico, no entanto, não oferece uma opção de difusão de tempo. No caso de um segundo bissexto, o relógio PTP físico adicionará o segundo bissexto de acordo com os padrões do UTC. As fontes de hora com difusão de segundo bissexto e sem difusão de segundos bissextos são iguais na maioria dos casos. Mas, como elas diferem durante um evento de segundo bissexto, não recomendamos o uso de ambas, as fontes de hora com difusão e sem difusão, na configuração do cliente de hora durante um evento de segundo bissexto.
**Topics**
+ [Carimbo de data e hora de pacotes de hardware](#hardware-packet-timestamping)
+ [Segundos bissextos](#leap-seconds)
+ [Definir a referência de horas na instância do EC2 para usar o Serviço de Sincronização Temporal da Amazon local](configure-ec2-ntp.md)
+ [Definir a referência de horas na instância do EC2 ou em qualquer dispositivo conectado à Internet para usar o Serviço de Sincronização Temporal da Amazon público](configure-time-sync.md)
+ [Comparação dos carimbos de data/hora das instâncias do Linux](compare-timestamps-with-clockbound.md)
+ [Alteração do fuso horário da instância](change-time-zone-of-instance.md)
**Recursos relacionados**
+ Blog de computação da AWS: [It’s About Time: Microsecond-Accurate Clocks on Amazon EC2 Instances](https://aws.amazon.com/blogs/compute/its-about-time-microsecond-accurate-clocks-on-amazon-ec2-instances/)
+ Blog da AWS sobre operações e migrações na nuvem: [Manage Amazon EC2 instance clock accuracy Amazon Time Sync Service and Amazon CloudWatch – Part 1](https://aws.amazon.com/blogs/mt/manage-amazon-ec2-instance-clock-accuracy-using-amazon-time-sync-service-and-amazon-cloudwatch-part-1/)
+ (Linux) [https://chrony-project.org/](https://chrony-project.org/)
# Definir a referência de horas na instância do EC2 para usar o Serviço de Sincronização Temporal da Amazon local
O Serviço de Sincronização Temporal da Amazon local usa o Network Time Protocol (NTP) ou fornece um relógio físico Precision Time Protocol (PTP) nas [instâncias compatíveis](#ptp-hardware-clock-requirements). O relógio físico PTP permite uma conexão NTP (instâncias Linux e Windows) ou uma conexão PTP direta (apenas instâncias Linux). As conexões NTP e PTP diretas usam a mesma fonte de hora extremamente exata, mas a conexão PTP direta é mais precisa do que a conexão NTP. A conexão NTP com o Serviço de Sincronização Temporal da Amazon usa a difusão de segundos bissextos, enquanto a conexão PTP com o relógio PTP físico não usa. Para obter mais informações, consulte [Segundos bissextos](set-time.md#leap-seconds).
As instâncias podem acessar o Serviço de Sincronização Temporal da Amazon da seguinte forma:
+ Por NTP nos seguintes endpoints de endereço IP:
+ IPv4: `169.254.169.123`
+ IPv6: `fd00:ec2::123` (Acessível somente em [instâncias baseadas em Nitro](instance-types.md#instance-hypervisor-type).)
+ (Somente para o Linux) Por meio de uma conexão PTP direta para se conectar a um relógio de hardware PTP local:
+ `PHC0`
As AMIs do Amazon Linux, as AMIs do Windows e a maioria das AMIs de parceiros configuram a instância para usar o endpoint do protocolo NTP para IPv4 por padrão. Esta é a configuração recomendada para a maioria das workloads do cliente. Nenhuma configuração adicional é necessária para instâncias iniciadas dessas AMIs, a menos que você queira usar o endpoint IPv6 ou se conectar diretamente ao relógio PTP físico.
As conexões NTP e PTP não exigem nenhuma alteração na configuração da VPC e a instância não requer acesso à Internet.
**Considerações**
+ Há um limite de 1.024 pacotes por segundo (PPS) para serviços que usam endereços [locais do link](using-instance-addressing.md#link-local-addresses). Esse limite inclui o agregado de [consultas ao DNS do Route 53 Resolver](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html#vpc-dns-limits), solicitações do [Serviço de metadados de instância (IMDS)](instancedata-data-retrieval.md), solicitações do Amazon Time Service Network Time Protocol (NTP) e solicitações do [Windows Licensing Service (para instâncias baseadas no Microsoft Windows)](https://aws.amazon.com/windows/resources/licensing/).
+ Somente as instâncias do Linux podem usar uma *conexão PTP direta* para se conectar ao relógio de hardware PTP local. As instâncias do Windows usam o protocolo NTP para se conectar ao relógio de hardware PTP local.
**Topics**
+ [Conectar-se ao endpoint IPv4 do Serviço de Sincronização Temporal da Amazon](#configure-amazon-time-service-IPv4)
+ [Conectar-se ao endpoint IPv6 do Serviço de Sincronização Temporal da Amazon](#configure-amazon-time-service-IPv6)
+ [Conectar-se ao relógio PTP físico](#connect-to-the-ptp-hardware-clock)
## Conectar-se ao endpoint IPv4 do Serviço de Sincronização Temporal da Amazon
É possível que a AMI já tenha configurado o Serviço de Sincronização Temporal da Amazon por padrão. Caso contrário, use os procedimentos a seguir para configurar sua instância de forma a usar o Serviço de Sincronização Temporal da Amazon local por meio do endpoint IPv4.
Para obter ajuda com a solução de problemas, consulte [Solucionar problemas de sincronização de NTP em instâncias Linux](https://repost.aws/knowledge-center/linux-troubleshoot-ntp-synchronization) ou [Solucionar problemas de horário em instâncias Windows](https://repost.aws/knowledge-center/ec2-windows-time-service).
------
#### [ Amazon Linux ]
O AL2023 e as versões recentes do Amazon Linux 2 são configuradas para usar o endpoint IPv4 do Serviço de Sincronização Temporal da Amazon por padrão. Se você confirmar que sua instância já está configurada, poderá pular o procedimento a seguir.
**Para verificar se o chrony está configurado para utilizar o endpoint IPv4**
Execute o comando a seguir. Na saída, a linha que começa com `^*` indica a fonte de horário preferencial.
```
chronyc sources -v | grep -F ^*
^* 169.254.169.123 3 4 377 14 +12us[+9653ns] +/- 290us
```
**Para configurar o chrony para conectar-se ao endpoint IPv4 em versões mais antigas do Amazon Linux 2**
1. Conecte-se à sua instância e desinstale o serviço NTP.
```
[ec2-user ~]$ sudo yum erase 'ntp*'
```
1. Instale o pacote `chrony`.
```
[ec2-user ~]$ sudo yum install chrony
```
1. Abra o arquivo `/etc/chrony.conf` usando um editor de texto (como **vim** ou **nano**). Adicione a linha a seguir antes de todas as outras instruções `server` ou `pool` que possam estar presentes no arquivo, e salve as alterações:
```
server 169.254.169.123 prefer iburst minpoll 4 maxpoll 4
```
1. Reinicie o daemon `chrony` (`chronyd`).
```
[ec2-user ~]$ sudo service chronyd restart
```
```
Starting chronyd: [ OK ]
```
**nota**
No RHEL e no CentOS (até a versão 6), o nome do serviço é `chrony` em vez de `chronyd`.
1. Para configurar o `chronyd` para ser iniciado a cada inicialização do sistema, use o comando `chkconfig`.
```
[ec2-user ~]$ sudo chkconfig chronyd on
```
1. Confirme que o `chrony` está usando o endpoint IPv4 `169.254.169.123` para sincronizar a hora.
```
[ec2-user ~]$ chronyc sources -v | grep -F ^*
```
Na saída, `^*` indica a fonte de horário preferencial.
```
^* 169.254.169.123 3 6 17 43 -30us[ -226us] +/- 287us
```
1. Verifique as métricas de sincronização da hora informadas pelo `chrony`.
```
[ec2-user ~]$ chronyc tracking
```
```
Reference ID : A9FEA97B (169.254.169.123)
Stratum : 4
Ref time (UTC) : Wed Nov 22 13:18:34 2017
System time : 0.000000626 seconds slow of NTP time
Last offset : +0.002852759 seconds
RMS offset : 0.002852759 seconds
Frequency : 1.187 ppm fast
Residual freq : +0.020 ppm
Skew : 24.388 ppm
Root delay : 0.000504752 seconds
Root dispersion : 0.001112565 seconds
Update interval : 64.4 seconds
Leap status : Normal
```
------
#### [ Ubuntu ]
**Para configurar o chrony para conectar-se ao endpoint IPv4 no Ubuntu**
1. Conecte-se à sua instância e use `apt` para instalar o pacote `chrony`.
```
ubuntu:~$ sudo apt install chrony
```
**nota**
Se necessário, atualize sua instância primeiro executando `sudo apt update`.
1. Abra o arquivo `/etc/chrony/chrony.conf` usando um editor de texto (como **vim** ou **nano**). Adicione a seguinte linha antes de todas as outras instruções `server` ou `pool` já presentes no arquivo, e salve as alterações:
```
server 169.254.169.123 prefer iburst minpoll 4 maxpoll 4
```
1. Reinicie o serviço `chrony`.
```
ubuntu:~$ sudo /etc/init.d/chrony restart
```
```
Restarting chrony (via systemctl): chrony.service.
```
1. Confirme que o `chrony` está usando o endpoint IPv4 `169.254.169.123` para sincronizar a hora.
```
ubuntu:~$ chronyc sources -v | grep -F ^*
```
Na saída, a linha que começa com `^*` indica a fonte de horário preferencial.
```
^* 169.254.169.123 3 6 17 12 +15us[ +57us] +/- 320us
```
1. Verifique as métricas de sincronização da hora informadas pelo `chrony`.
```
ubuntu:~$ chronyc tracking
```
```
Reference ID : 169.254.169.123 (169.254.169.123)
Stratum : 4
Ref time (UTC) : Wed Nov 29 07:41:57 2017
System time : 0.000000011 seconds slow of NTP time
Last offset : +0.000041659 seconds
RMS offset : 0.000041659 seconds
Frequency : 10.141 ppm slow
Residual freq : +7.557 ppm
Skew : 2.329 ppm
Root delay : 0.000544 seconds
Root dispersion : 0.000631 seconds
Update interval : 2.0 seconds
Leap status : Normal
```
------
#### [ SUSE Linux ]
A partir do SUSE Linux Enterprise Server 15, o `chrony` é a implementação padrão do NTP.
**Para configurar o chrony para conectar-se ao endpoint IPv4 no SUSE Linux**
1. Abra o arquivo `/etc/chrony.conf` usando um editor de texto (como **vim** ou **nano**).
1. Verifique se o arquivo contém a seguinte linha:
```
server 169.254.169.123 prefer iburst minpoll 4 maxpoll 4
```
Se essa linha não estiver presente, adicione-a.
1. Comente qualquer outro servidor ou linhas de consulta.
1. Abra o YaST e ative o serviço chrony.
------
#### [ Windows ]
A versão das AMIs do Windows de agosto de 2018 em diante usam o Amazon Time Sync Service por padrão. Nenhuma configuração adicional é necessária para instâncias iniciadas dessas AMIs e você pode ignorar os procedimentos a seguir.
Se você estiver usando uma AMI que não tenha o Serviço de Sincronização Temporal da Amazon configurado por padrão, primeiro verifique sua configuração atual do protocolo NTP. Se a instância já estiver usando o endpoint IPv4 do Serviço de Sincronização Temporal da Amazon, nenhuma configuração adicional será necessária. Se a instância não estiver usando o Serviço de Sincronização Temporal da Amazon, faça o procedimento para alterar o servidor NTP para que use o Serviço de Sincronização Temporal da Amazon.
**Para verificar a configuração de NTP**
1. Na instância, abra uma janela de prompt de comando.
1. Obtenha a configuração de NTP atual digitando o seguinte comando:
```
w32tm /query /configuration
```
Esse comando retorna as definições de configuração atuais para a instância do Windows e mostrará se você está conectado ao Serviço de Sincronização Temporal da Amazon.
1. (Opcional) Obtenha o status da configuração atual digitando o seguinte comando:
```
w32tm /query /status
```
Esse comando retorna informações, como o último horário em que a instância foi sincronizada com o servidor NTP e o intervalo de sondagem.
**Para alterar o servidor NTP para usar o Amazon Time Sync Service**
1. Na janela de prompt de comando, execute o seguinte comando:
```
w32tm /config /manualpeerlist:169.254.169.123 /syncfromflags:manual /update
```
1. Verifique suas novas configurações usando o seguinte comando:
```
w32tm /query /configuration
```
Na saída retornada, verifique se `NtpServer` exibe o endpoint IPv4 `169.254.169.123`.
**Configurações padrão de NTP para AMIs da Amazon para o Windows**
As Imagens de máquina da Amazon (AMIs) geralmente aderem aos padrões prontos para uso, exceto em casos em que alterações são necessárias para que funcionem na infraestrutura do EC2. As seguintes configurações foram determinadas para funcionar de maneira adequada em um ambiente virtual, bem como manter qualquer desvio de relógio dentro um segundo de precisão:
+ **Intervalo de atualização**: rege a frequência com que o serviço de hora acertará a hora do sistema para garantir sua precisão. A AWS configura o intervalo de atualização para ocorrer uma vez a cada dois minutos.
+ **Servidor NTP**: a partir da versão de agosto de 2018, as AMIs usam o Serviço de Sincronização Temporal da Amazon por padrão. Esse serviço de horário pode ser acessado em qualquer Região da AWS no endpoint IPv4 169.254.169.123. Além disso, o sinalizador 0x9 indica que o serviço de horário está atuando como um cliente e utiliza o `SpecialPollInterval` para determinar a frequência com a qual realizar verificações com o servidor de horário configurado.
+ **Tipo** – "NTP" significa que o serviço atua como um cliente NTP autônomo em vez de agir como parte de um domínio.
+ **Habilitado e InputProvider**: o serviço de hora está habilitado e fornece a hora ao sistema operacional.
+ **Intervalo de pesquisa especial**: verifica o servidor NTP configurado a cada 900 segundos (15 minutos).
**nota**
Para as AMIs do Windows Server 2025, o valor de `SpecialPollInterval` é de 1024 segundos, em vez de 900 segundos.
| Caminho de registro | Nome da chave | Dados |
| --- | --- | --- |
| HKLM:\$1System\$1CurrentControlSet\$1services\$1w32time\$1Config | UpdateInterval | 120 |
| HKLM:\$1System\$1CurrentControlSet\$1services\$1w32time\$1Parameters | NtpServer | 169.254.169.123,0x9 |
| HKLM:\$1System\$1CurrentControlSet\$1services\$1w32time\$1Parameters | Tipo | NTP |
| HKLM:\$1System\$1CurrentControlSet\$1services\$1w32time\$1TimeProviders\$1NtpClient | Enabled | 1 |
| HKLM:\$1System\$1CurrentControlSet\$1services\$1w32time\$1TimeProviders\$1NtpClient | InputProvider | 1 |
| HKLM:\$1System\$1CurrentControlSet\$1services\$1w32time\$1TimeProviders\$1NtpClient | SpecialPollInterval | 900 (Windows Server 2016, 2019 e 2022) ou 1024 (Windows Server 2025) |
------
## Conectar-se ao endpoint IPv6 do Serviço de Sincronização Temporal da Amazon
Esta seção explica como as etapas descritas no [Conectar-se ao endpoint IPv4 do Serviço de Sincronização Temporal da Amazon](#configure-amazon-time-service-IPv4) diferem se você estiver configurando a instância para usar o Serviço de Sincronização Temporal da Amazon local por meio do endpoint IPv6. Ela não explica todo o processo de configuração do Amazon Time Sync Service.
O endpoint IPv6 só é acessível em [instâncias baseadas em Nitro](instance-types.md#instance-hypervisor-type).
Não recomendamos usar as entradas de endpoint IPv4 e IPv6 em conjunto. Os pacotes IPv4 e IPv6 NTP vêm do mesmo servidor local para a sua instância. Configurar ambos os endpoints IPv4 e IPv6 é desnecessário e não melhorará a precisão da hora na instância.
------
#### [ Linux ]
Dependendo da distribuição do Linux que está usando, ao chegar à etapa de edição do arquivo `chrony.conf`, você estará usando o endpoint IPv6 do Serviço de Sincronização Temporal da Amazon (`fd00:ec2::123`) em vez do endpoint IPv4 (`169.254.169.123`):
```
server fd00:ec2::123 prefer iburst minpoll 4 maxpoll 4
```
Salve o arquivo e confirme que o chrony está usando o endpoint IPv6 `fd00:ec2::123` para sincronizar a hora:
```
[ec2-user ~]$ chronyc sources -v
```
Na saída, se você vir o endpoint IPv6 `fd00:ec2::123`, a configuração estará concluída.
------
#### [ Windows ]
Ao chegar à etapa de alteração do servidor NTP para usar o Serviço de Sincronização Temporal da Amazon, você estará usando o endpoint IPv6 do Serviço de Sincronização Temporal da Amazon (`fd00:ec2::123`) em vez do endpoint IPv4 (`169.254.169.123`):
```
w32tm /config /manualpeerlist:fd00:ec2::123 /syncfromflags:manual /update
```
Verifique se as novas configurações estão usando o endpoint IPv6 `fd00:ec2::123` para sincronizar o horário:
```
w32tm /query /configuration
```
Na saída, verifique se `NtpServer` exibe o endpoint IPv6 `fd00:ec2::123`.
------
## Conectar-se ao relógio PTP físico
O relógio de hardware baseado em PTP faz parte do [AWS Nitro System](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), portanto, pode ser acessado diretamente em [instâncias bare metal e virtualizadas do EC2 com suporte](#ptp-hardware-clock-requirements), sem a necessidade de usar recursos do cliente.
Os endpoints NTP para o relógio de hardware PTP são os mesmos do Serviço de Sincronização Temporal da Amazon normal. Se a instância tiver um relógio de hardware PTP e você tiver configurado a conexão NTP (com o endpoint IPv4 ou IPv6), a hora da instância será automaticamente obtida do relógio de hardware PTP via NTP.
Para instâncias do Linux, é possível configurar uma conexão PTP *direta*, o que fornecerá uma hora mais precisa do que a conexão NTP. As instâncias do Windows só são compatíveis com uma conexão NTP para o relógio de hardware PTP.
### Requisitos
O relógio PTP físico está disponível em uma instância quando os seguintes requisitos são atendidos:
+ Regiões da AWS com suporte: Leste dos EUA (Norte da Virgínia), Leste dos EUA (Ohio), Ásia-Pacífico (Malásia), Ásia-Pacífico (Tailândia), Ásia-Pacífico (Tóquio) e Europa (Estocolmo)
+ Zonas locais compatíveis: Leste dos EUA (Cidade de Nova York)
+ Famílias de instâncias suportadas:
+ **Uso geral: **M7a, M7g, M7i
+ **Otimizadas para memória: **R7a, R7g, R7i
+ **Otimizadas para armazenamento: **I8g, I8ge
+ (Somente Linux) Driver do ENA, na versão 2.10.0 ou em versões posteriores, instalado em um sistema operacional compatível. *Para obter mais informações sobre os sistemas operacionais compatíveis, consulte os [pré-requisitos](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#prerequisites) do driver no GitHub.*
### (Somente Linux) Configurar uma conexão PTP direta com o relógio de hardware PTP
Esta seção descreve como configurar a instância do Linux para usar o Serviço de Sincronização Temporal da Amazon local por meio do relógio de hardware PTP usando uma conexão PTP direta. É necessário adicionar uma entrada do servidor para o relógio de hardware PTP ao arquivo de configuração do `chrony`.
**Para configurar uma conexão PTP direta com o relógio de hardware PTP (somente instâncias do Linux)**
1. **Pré-requisitos de instalação**
Conecte-se à sua instância do Linux e faça o seguinte:
1. Instale o driver do kernel Linux para o Adaptador de Rede Elástica (ENA) versão 2.10.0 ou posterior.
1. Habilite o relógio de hardware PTP.
Para obter as instruções de instalação, consulte [Linux kernel driver for Elastic Network Adapter (ENA) family](https://github.com/amzn/amzn-drivers/tree/master/kernel/linux/ena#linux-kernel-driver-for-elastic-network-adapter-ena-family) no *GitHub.*
1. **Verificar o dispositivo ENA PTP**
Verifique se o dispositivo de relógio de hardware ENA PTP aparece em sua instância.
```
[ec2-user ~]$ for file in /sys/class/ptp/*; do echo -n "$file: "; cat "$file/clock_name"; done
```
Saída esperada
```
/sys/class/ptp/ptp: ena-ptp-
```
Em que:
+ `index` é o índice de relógio de hardware PTP registrado no kernel.
+ `PCI slot` é o slot PCI do controlador Ethernet ENA. É o mesmo slot mostrado em `lspci | grep ENA`.
Exemplo de saída
```
/sys/class/ptp/ptp0: ena-ptp-05
```
Se `ena-ptp-` não estiver na saída, o driver ENA não foi instalado corretamente. Revise a etapa 1 desse procedimento para instalar o driver.
1. **Configurar o link simbólico PTP**
Os dispositivos PTP geralmente são nomeados `/dev/ptp0`, `/dev/ptp1` e assim por diante, e o índice depende da ordem de inicialização do hardware. A criação de um link simbólico garante que aplicações como o chrony façam referência consistentementemente ao dispositivo correto, independentemente das alterações no índice.
As AMIs mais recentes do Amazon Linux 2023 incluem uma regra `udev` que cria o link simbólico `/dev/ptp_ena`, apontando para a entrada `/dev/ptp` correta associada ao host ENA.
Primeiro, verifique se o link simbólico está presente executando o seguinte comando.
```
[ec2-user ~]$ ls -l /dev/ptp*
```
Exemplo de saída
```
crw------- 1 root root 245, 0 Jan 31 2025 /dev/ptp0
lrwxrwxrwx 1 root root 4 Jan 31 2025 /dev/ptp_ena -> ptp0
```
Em que:
+ `/dev/ptp` é o caminho para o dispositivo PTP.
+ `/dev/ptp_ena` é o link simbólico constante, que aponta para o mesmo dispositivo PTP.
Se o link simbólico `/dev/ptp_ena` estiver presente, pule para a Etapa 4 deste procedimento. Se estiver faltando, faça o seguinte:
1. Adicione a seguinte regra `udev`.
```
[ec2-user ~]$ echo "SUBSYSTEM==\"ptp\", ATTR{clock_name}==\"ena-ptp-*\", SYMLINK += \"ptp_ena\"" | sudo tee -a /etc/udev/rules.d/53-ec2-network-interfaces.rules
```
1. Recarregue a regra `udev`, reiniciando a instância ou executando o comando a seguir.
```
[ec2-user ~]$ sudo udevadm control --reload-rules && udevadm trigger
```
1. **Configurar o chrony**
O chrony deve ser configurado para usar o link simbólico `/dev/ptp_ena` em vez de referenciar /`dev/ptp` diretamente.
1. Edite o `/etc/chrony.conf` o usando um editor de texto e adicione a linha a seguir em qualquer ponto no arquivo.
```
refclock PHC /dev/ptp_ena poll 0 delay 0.000010 prefer
```
1. Reinicie o chrony.
```
[ec2-user ~]$ sudo systemctl restart chronyd
```
1. **Verificar configuração do chrony**
Verifique se o chrony está usando o relógio PTP físico para sincronizar a hora nessa instância.
```
[ec2-user ~]$ chronyc sources
```
Saída esperada
```
MS Name/IP address Stratum Poll Reach LastRx Last sample
===============================================================================
#* PHC0 0 0 377 1 +2ns[ +1ns] +/- 5031ns
```
Na saída retornada, `*` indica a fonte de hora preferida. `PHC0` corresponde ao relógio PTP físico. Pode ser necessário esperar alguns segundos após reiniciar o chrony para que o asterisco apareça.
# Definir a referência de horas na instância do EC2 ou em qualquer dispositivo conectado à Internet para usar o Serviço de Sincronização Temporal da Amazon público
É possível configurar a instância ou qualquer dispositivo conectado à Internet, como seu computador local ou um servidor local, para usar o Serviço de Sincronização Temporal da Amazon público, que pode ser acessado pela Internet em `time.aws.com`. É possível usar o Serviço de Sincronização Temporal da Amazon público como backup para o Serviço de Sincronização Temporal da Amazon e para conectar recursos de fora da AWS ao Serviço de Sincronização Temporal da Amazon.
**nota**
Para obter a melhor performance, recomendamos usar o Serviço de Sincronização Temporal da Amazon *local* nas instâncias e usar o Serviço de Sincronização Temporal da Amazon *público* somente como backup.
Use as instruções referentes ao sistema operacional da sua instância ou do seu dispositivo.
## Linux
**Para definir que a instância ou dispositivo com Linux use o Serviço de Sincronização Temporal da Amazon público usando chrony ou ntpd**
1. Edite o `/etc/chrony.conf` (se você usar o chrony) ou o `/etc/ntp.conf` (se você usar o ntpd) usando um de texto da seguinte maneira:
1. Para evitar que a instância ou o dispositivo tente misturar servidores com difusão de tempo e servidores sem difusão de tempo, remova ou comente as linhas que começam com `server`, exceto qualquer conexão existente com o Serviço de Sincronização Temporal da Amazon local.
**Importante**
Se você estiver configurando sua instância do EC2 para se conectar ao Serviço de Sincronização Temporal da Amazon público, não remova a linha a seguir que a instância deve se conectar ao Serviço de Sincronização Temporal da Amazon local. O Serviço de Sincronização Temporal da Amazon local é uma conexão mais direta e garantirá uma maior precisão do relógio. O Serviço de Sincronização Temporal da Amazon público só deve ser usado como backup.
```
server 169.254.169.123 prefer iburst minpoll 4 maxpoll 4
```
1. Adicione a seguinte linha para se conectar ao Serviço de Sincronização Temporal da Amazon.
```
pool time.aws.com iburst
```
1. Reinicie o daemon usando um dos comandos a seguir.
+ chrony
```
sudo service chronyd force-reload
```
+ ntpd
```
sudo service ntp reload
```
## macOS
**Para definir que a instância ou dispositivo com macOS use o Serviço de Sincronização Temporal da Amazon público**
1. Abra **System Preferences (Preferências do sistema)**.
1. Escolha **Date & Time** (Data e hora) e, em seguida, escolha a guia **Date & Time** (Data e hora).
1. Para fazer alterações, escolha o ícone de cadeado e digite sua senha quando solicitado.
1. Em **Definir data e hora automaticamente**, insira **time.aws.com**.
## Windows
**Para definir que a instância ou dispositivo com Windows use o Serviço de Sincronização Temporal da Amazon público**
1. Abra o **Control Panel** (Painel de controle).
1. Escolha o ícone de **Date and Time** (Data e hora).
1. Escolha a guia **Internet Time** (Horário da Internet). Essa guia não estará disponível se o PC fizer parte de um domínio. Nesse caso, a hora será sincronizada com o controlador de domínio. É possível configurar o controlador para usar o Serviço de Sincronização Temporal da Amazon público.
1. Escolha **Change settings** (Alterar configurações).
1. Marque a caixa de seleção em **Sincronizar com um servidor de hora na Internet**.
1. Ao lado de **Servidor**, insira **time.aws.com**.
**Para definir que a instância ou dispositivo com Windows Server use o Serviço de Sincronização Temporal da Amazon público**
+ Siga as [instruções da Microsoft](https://support.microsoft.com/en-us/kb/816042) para atualizar o registro.
# Comparação dos carimbos de data/hora das instâncias do Linux
Se estiver usando o Serviço de Sincronização Temporal da Amazon, será possível comparar os carimbos de data/hora nas instâncias do Linux do Amazon EC2 com o ClockBound para determinar o horário real de um evento. O ClockBound mede a precisão do relógio da instância do EC2 e permite que você confira se um determinado carimbo de data/hora está no passado ou no futuro em relação ao relógio atual da instância. Essas informações são valiosas para determinar a ordem e a consistência de eventos e transações entre instâncias do EC2, independentemente da localização geográfica de cada instância.
O ClockBound é um daemon e uma biblioteca de código aberto. Para saber mais sobre o ClockBound, incluindo instruções de instalação, consulte [Clockbound](https://github.com/aws/clock-bound) no *GitHub*.
O ClockBound é compatível somente com instâncias do Linux.
Se você estiver usando a conexão PTP direta com o relógio PTP físico, seu daemon de hora, como o chrony, subestimará o limite de erro do relógio. Isso ocorre porque um relógio PTP físico não passa as informações corretas de limite de erro para o chrony, como o NTP faz. Como resultado, o daemon de sincronização de relógio pressupõe que o relógio esteja certo em UTC e que, portanto, tenha um limite de erro de `0`. Para medir o limite total de erro, o Sistema Nitro calcula o limite de erro do relógio PTP físico e o disponibiliza para a instância do EC2 via sistema de arquivos `sysfs` do driver ENA. Isso pode ser lido diretamente como um valor em nanossegundos.
**Para recuperar o limite de erro do relógio de hardware PTP**
1. Primeiro, obtenha a localização correta do dispositivo de relógio de hardware PTP usando um dos comandos a seguir. O caminho no comando pode ser diferente dependendo da AMI usada para iniciar a instância.
+ Para Amazon Linux 2:
```
cat /sys/class/net/eth0/device/uevent | grep PCI_SLOT_NAME
```
+ Para Amazon Linux 2023:
```
cat /sys/class/net/ens5/device/uevent | grep PCI_SLOT_NAME
```
A saída é o nome do slot PCI, que é a localização do dispositivo de relógio de hardware PTP físico. Neste exemplo, o local é `0000:00:03.0`.
```
PCI_SLOT_NAME=0000:00:03.0
```
1. Para recuperar erro do relógio de hardware PTP vinculado execute o comando a seguir. Inclua o nome do slot PCI da etapa anterior.
```
cat /sys/bus/pci/devices/0000:00:03.0/phc_error_bound
```
A saída é o limite de erro do relógio PTP físico, em nanossegundos.
Para calcular o limite de erro de relógio certo em um dado momento específico ao usar a conexão PTP direta com o relógio PTP físico, você deve adicionar o limite de erro do relógio do chrony ou do ClockBound no momento em que o chrony consultar o relógio PTP físico. Para obter mais informações sobre como medir e monitorar a precisão do relógio, consulte [Manage Amazon EC2 instance clock accuracy using Amazon Time Sync Service and Amazon CloudWatch – Part 1](https://aws.amazon.com/blogs/mt/manage-amazon-ec2-instance-clock-accuracy-using-amazon-time-sync-service-and-amazon-cloudwatch-part-1/).
# Alteração do fuso horário da instância
As instâncias do Amazon EC2 são definidas para o fuso horário UTC (Tempo Universal Coordenado), por padrão. É possível alterar a hora de uma instância para o horário local ou para outro fuso horário em sua rede.
Use as instruções para o sistema operacional da sua instância.
## Linux
**Importante**
Essas informações se aplicam ao Amazon Linux. Para obter informações sobre outras distribuições, consulte a documentação específica.
**Para alterar o fuso horário no Amazon Linux**
1. Exiba a configuração atual de fuso horário do sistema.
```
[ec2-user ~]$ timedatectl
```
1. Liste os fusos horários disponíveis.
```
[ec2-user ~]$ timedatectl list-timezones
```
1. Defina o fuso horário escolhido.
```
[ec2-user ~]$ sudo timedatectl set-timezone America/Vancouver
```
1. (Opcional) Confirme se o fuso horário atual foi atualizado para o novo fuso horário executando o comando **timedatectl** novamente.
```
[ec2-user ~]$ timedatectl
```
## Windows
**Para alterar o fuso horário de uma instância do Windows**
1. Na instância, abra uma janela de prompt de comando.
1. Identifique o fuso horário a ser usado na instância. Para obter uma lista de fusos horários, use o seguinte comando:
```
tzutil /l
```
Esse comando retorna uma lista com todos os fusos horários disponíveis no seguinte formato:
```
display name
time zone ID
```
1. Localize o ID do fuso horário a ser atribuído à instância.
1. Exemplo: atribuir o fuso horário UTC:
```
tzutil /s "UTC"
```
Exemplo: atribuir o horário padrão do Pacífico:
```
tzutil /s "Pacific Standard Time"
```
Quando você altera o fuso horário em uma instância do Windows, deve garantir que ele seja mantido durante as reinicializações de sistema. Caso contrário, quando a instância for reiniciada, ela voltará a usar o horário UTC. É possível conservar o horário adicionando a chave do registro **RealTimeIsUniversal**. Essa chave é definida por padrão em todas as instâncias da geração atual. Para verificar se a chave de registro **RealTimeIsUniversal** está configurada, consulte a Etapa 3 no procedimento apresentado a seguir. Se a chave não estiver definida, siga estas etapas desde o início.
**Para definir a chave do Registro RealTimeIsUniversal**
1. Na instância, abra uma janela de prompt de comando.
1. Use o seguinte comando para adicionar a chave de Registro:
```
reg add "HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\TimeZoneInformation" /v RealTimeIsUniversal /d 1 /t REG_DWORD /f
```
1. (Opcional) Verifique se a instância salvou a chave com êxito usando o seguinte comando:
```
reg query "HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\TimeZoneInformation" /s
```
Esse comando retorna as subchaves da chave de Registro **TimeZoneInformation**. É necessário ver a chave **RealTimeIsUniversal** na parte inferior da lista, semelhante à chave a seguir:
```
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\TimeZoneInformation
Bias REG_DWORD 0x1e0
DaylightBias REG_DWORD 0xffffffc4
DaylightName REG_SZ @tzres.dll,-211
DaylightStart REG_BINARY 00000300020002000000000000000000
StandardBias REG_DWORD 0x0
StandardName REG_SZ @tzres.dll,-212
StandardStart REG_BINARY 00000B00010002000000000000000000
TimeZoneKeyName REG_SZ Pacific Standard Time
DynamicDaylightTimeDisabled REG_DWORD 0x0
ActiveTimeBias REG_DWORD 0x1a4
RealTimeIsUniversal REG_DWORD 0x1
```