Prompt

Qual recomendação de hardware, usando Linux, para a utilização da solução de OCR, Paddle OCR, com volumetria de 60 requests por minuto?

Gemini

Para a sua necessidade de rodar o PaddleOCR com um volume de 60 requisições por minuto, a principal recomendação de hardware, utilizando Linux, é focar em uma GPU dedicada da NVIDIA. O PaddleOCR, assim como a maioria das soluções de OCR modernas, utiliza modelos de aprendizado de máquina que se beneficiam enormemente da aceleração proporcionada por GPUs. Processar 60 requisições por minuto significa uma média de uma requisição por segundo, e uma GPU é a maneira mais eficiente de garantir que cada uma seja processada rapidamente.

A escolha de hardware ideal depende muito da complexidade das suas imagens (resolução, quantidade de texto, etc.), mas aqui está uma recomendação geral que deve atender a sua demanda de forma robusta e eficiente.

Componentes-Chave

GPU (Placa de Vídeo)

Recomendado: Uma NVIDIA GeForce RTX 3060 (12 GB) ou superior.
Por que? A arquitetura CUDA da NVIDIA é fundamental para o desempenho do PaddleOCR. O modelo de 12 GB de VRAM (memória de vídeo) da RTX 3060 é um ponto ideal para a maioria das cargas de trabalho de OCR, pois a memória de vídeo é crítica para carregar os modelos de deep learning e processar imagens grandes. Além disso, a série RTX é otimizada para tarefas de IA e machine learning.
Alternativa: Se o orçamento permitir, uma NVIDIA GeForce RTX 3070 (8 GB) ou RTX 4070 (12 GB) também seria uma excelente opção, oferecendo mais poder de processamento. Para orçamentos mais apertados, a NVIDIA GeForce RTX 2060 (6 GB) pode ser uma opção viável, mas talvez não tão escalável a longo prazo.

CPU (Processador)

Recomendado: Um processador da linha Intel Core i5 (de 10ª geração ou mais recente) ou AMD Ryzen 5 (de 3ª geração ou mais recente).
Por que? Embora a GPU faça a maior parte do trabalho de processamento do OCR, a CPU ainda é responsável por coordenar as tarefas, carregar os dados e gerenciar o sistema operacional. Um processador de gama média moderna é mais do que suficiente para evitar gargalos e garantir um fluxo de trabalho suave.

RAM (Memória)

Recomendado: 16 GB de RAM.
Por que? É o padrão mínimo para sistemas modernos que executam tarefas de machine learning. Isso garante que o sistema operacional, os processos do PaddleOCR e outros aplicativos em segundo plano tenham espaço suficiente para funcionar sem lentidão. Se você planeja rodar outras aplicações ou modelos maiores, 32 GB seria uma opção mais segura.

Armazenamento

Recomendado: SSD de 500 GB ou 1 TB.
Por que? O uso de um SSD (Solid State Drive) é crucial para tempos de inicialização rápidos, carregamento rápido dos modelos do PaddleOCR e acesso ágil aos arquivos. Isso melhora a experiência geral e a responsividade do sistema. O tamanho de 500 GB é um bom ponto de partida, mas 1 TB oferece mais espaço para armazenamento de dados e imagens.

Configuração do Software no Linux

Depois de montar o hardware, a configuração do software é a próxima etapa crucial para garantir o desempenho ideal.

Escolha uma distribuição Linux: O Ubuntu LTS (Long Term Support) é a opção mais recomendada. É amplamente utilizado na comunidade de IA e machine learning, o que significa que a maioria das ferramentas e drivers tem suporte robusto para ele.
Instale os drivers da NVIDIA: É fundamental instalar a versão mais recente dos drivers proprietários da NVIDIA. O ubuntu-drivers autoinstall é uma maneira fácil de fazer isso no Ubuntu.
Instale o CUDA e o cuDNN: Essas são as ferramentas de aceleração da NVIDIA que o PaddleOCR utiliza para rodar na GPU. É importante instalar versões que sejam compatíveis tanto com o seu driver quanto com a versão do PaddleOCR que você vai usar.
Instale o PaddlePaddle e o PaddleOCR: Utilize o pip para instalar as bibliotecas, garantindo que a versão com suporte a GPU seja a correta (por exemplo, pip install paddlepaddle-gpu e pip install "paddleocr").

Ao focar nessa combinação de hardware, você terá uma máquina robusta e otimizada para lidar com a sua volumetria de 60 requisições por minuto no PaddleOCR, garantindo um bom desempenho e escalabilidade futura.

ChatGPT

Boa! Para 60 requisições/min (≈1 RPS) o PaddleOCR roda tranquilo em Linux com CPU boa — GPU só é necessária se você quiser latência bem baixa, modelos maiores ou margem para picos. Abaixo vão recomendações objetivas, já pensando em PP-OCRv3/PP-OCRv4 (det + rec), imagens até ~2–8 MP e latência-alvo < 500–800 ms por imagem.

Recomendações de hardware (Linux)

Nível 1 — CPU-only (suficiente para 60 RPM)

Processador:
- Intel Core i5-13400/14400 ou i7-12700/13700
- (alternativa AMD) Ryzen 5 5600/7600 ou Ryzen 7 5700X/7700
Memória: 16–32 GB DDR4/DDR5
Disco: NVMe 500 GB (IOPS alto ajuda no cache/modelos)
SO: Ubuntu Server 22.04 LTS
Observação de capacidade: com 4–8 workers (processos) e MKL/oneDNN habilitados, atende 60 RPM com folga para picos modestos.

Nível 2 — Desktop GPU (latência menor e folga para picos)

CPU: i5/i7 da geração atual ou Ryzen 5/7
GPU (CUDA): RTX 3060 12 GB ou RTX 4060 Ti 16 GB
Memória: 32 GB
Disco: NVMe 1 TB
SO: Ubuntu 22.04 + CUDA 12.x + cuDNN
Observação: reduz a latência (det+rec) e permite modelos multilíngues/maiores sem suar. 60 RPM vira carga leve.

Nível 3 — Datacenter/produção com alta folga

Servidor: 1× NVIDIA T4 16 GB ou L4 24 GB (melhor)
CPU: 8–16 vCPU
Memória: 32–64 GB
Armazenamento: NVMe 1 TB
SO: Ubuntu 22.04 + CUDA/cuDNN + TensorRT
Observação: sobra capacidade (centenas de RPM), ideal se houver picos, múltiplas filas, vários modelos.

Configuração de software e tuning (vale para qualquer nível)

Runtime: Docker + Compose/K8s.
Framework: PaddleOCR com Paddle Inference.
Aceleração:
- CPU: habilite mkldnn=True, cpu_threads=2–4 por worker; exporte OMP_NUM_THREADS e MKL_NUM_THREADS coerentes.
- GPU: use_gpu=True, use_tensorrt=True, precision=fp16 (se ok para sua acurácia).
Pré-processamento: redimensione o lado maior para 960–1280 px (evita penalidade em fotos 12 MP).
Concorrência: 4–8 workers (Gunicorn/Uvicorn) + batch size = 1 (OCR não se beneficia muito de batch grande).
Warm-up: carregue modelos no startup de cada worker.
Cache: mantenha modelos em disco local NVMe; evite volumes de rede.
Timeout: 5–10 s por request (com circuito para imagens problemáticas).
Observabilidade: Prometheus + Grafana (latência p50/p95, uso CPU/GPU, filas).

Arquitetura de referência

Gateway (Nginx/Traefik) → API (FastAPI/Flask) → Workers OCR (CPU/GPU)
Fila opcional (Redis + RQ/Celery) se houver “rajadas” ou processamento assíncrono.
HA: 2 nós idênticos atrás de um load balancer se disponibilidade for requisito.

Tamanhos prontos (compra rápida)

Opção econômica (CPU-only, atende 60 RPM)

Intel i7-13700, 32 GB RAM, NVMe 1 TB, Ubuntu 22.04.
Esperado: ~1–3 imagens/s agregadas com 6–8 workers → folga para 60 RPM e picos.

Opção com GPU de mesa (baixa latência + folga)

Ryzen 7 7700, RTX 4060 Ti 16 GB, 32 GB RAM, NVMe 1 TB, Ubuntu 22.04 + CUDA 12.x.
Esperado: latências menores e ampla margem para crescer > 60 RPM.

Opção servidor (escala futura)

1× L4 24 GB, 8–16 vCPU, 64 GB RAM, NVMe 1 TB.
Esperado: centenas de RPM com p95 baixo, pronto para múltiplos modelos/idiomas.

Dicas finais de operação

Teste com seu perfil real de imagens (A4 300 dpi vs. fotos) — o insumo domina a latência.
Quantização: experimente FP16/INT8 (TensorRT) em GPU; em CPU, use INT8 com oneDNN se a acurácia permanecer ok.
Modelos: para PT/EN, use modelos “multilingual” do PaddleOCR; mantenha um pipeline leve (det pequeno + rec adequado ao idioma).
Picos: se houver rajadas (ex.: 10–20 RPS por minutos), prefira GPU ou escale horizontalmente.

Se quiser, já te entrego um docker-compose.yml + gunicorn.conf.py prontos com as flags (CPU ou GPU) e números de workers calibrados para começar.

DeepSeek

Claro! Recomendar hardware para o Paddle OCR com uma volumetria de 60 requests por minuto (1 req/s) é um exercício que envolve entender como o Paddle funciona e onde estão os gargalos.

A boa notícia é que 60 RPM é uma carga moderada e pode ser atendida com hardware relativamente acessível, especialmente se você usar GPU.

Análise da Carga de Trabalho (60 RPM)

1 requisição por segundo: Isso significa que, em média, o sistema tem 1 segundo para processar cada imagem. No entanto, as requisições não chegam perfeitamente distribuídas. Você precisa de hardware que consiga lidar com picos de talvez 3-5 requisições simultâneas sem travar.
Complexidade do Paddle OCR: O processo envolve dois modelos principais:
1. Detecção de Texto: Localiza as caixas de texto na imagem.
2. Reconhecimento de Texto (OCR): Extrai o texto de cada caixa identificada.
Fatores Críticos: A velocidade depende principalmente de:
- GPU: É o maior acelerador. Um modelo médio como ch_PP-OCRv3_det + ch_PP-OCRv3_rec roda na faixa de 10ms a 50ms por imagem em uma GPU dedicada moderna, dependendo do tamanho e complexidade da imagem.
- CPU: É crucial para o pré e pós-processamento (decodificar a imagem, redimensionar, ordenar resultados, executar a lógica da aplicação) e para executar os modelos se você não usar GPU.
- RAM: 16 GB são suficientes, mas 32 GB dão folga para o sistema operacional e outros processos.

Recomendações de Hardware

Aqui estão duas recomendações: uma econômica (baseada em CPU) e uma ideal (baseada em GPU).

Opção 1: Configuração Econômica (CPU only)

Esta opção é viável para 60 RPM, mas os tempos de resposta serão mais altos (provavelmente entre 1 a 3 segundos por request) e a latência será menos consistente. É uma opção se o orçamento for muito restrito.

CPU: Intel Core i7-12700K ou AMD Ryzen 7 5700X (ou superior). Essas CPUs têm um bom número de núcleos (8+ núcleos/16+ threads) e alta frequência, o que é importante para inferência via CPU.
RAM: 16 GB DDR4 3200MHz. É o mínimo recomendado. 32 GB seriam mais confortáveis se você planeja rodar outros serviços no mesmo servidor.
Armazenamento: SSD NVMe de 512 GB. A leitura/gravação rápida é essencial para carregar os modelos na RAM rapidamente na inicialização e para o sistema operacional.
GPU: Integrada ou muito básica (apenas para vídeo). O trabalho pesado será todo na CPU.
Observação: Com esta configuração, é mandatório usar as versões mais leves dos modelos do Paddle OCR (como o ch_PP-OCRv3_det + ch_PP-OCRv3_rec) e otimizar o código para usar quantização (por exemplo, com ONNX Runtime) para maximizar o desempenho da CPU.

Opção 2: Configuração Recomendada e Ideal (Com GPU)

Esta é a configuração que entregará a melhor experiência: baixa latência (menos de 1s por request) e alta consistência, mesmo sob picos de carga.

GPU: NVIDIA GeForce RTX 3060 (12 GB) ou RTX 4060 Ti (16 GB).
- Por quê? A VRAM (memória da GPU) é crucial. Modelos de OCR médios consomem cerca de 2-4 GB. Ter 12 GB ou mais permite processar várias requisições em paralelo (usando batch processing) sem ficar sem memória. A arquitetura Ampere (RTX 30xx) e Ada Lovelace (RTX 40xx) têm ótimo suporte ao CUDA e Tensor Cores para inferência.
- Alternativas: Uma RTX 3070/4070 ou uma GPU de servidor usada como uma Tesla P100 também são excelentes opções.
CPU: Intel Core i5-12400 ou AMD Ryzen 5 5600X. Como a GPU fará o trabalho pesado, a CPU pode ser de médio alcance. 6 núcleos modernos são mais que suficientes para alimentar a GPU e lidar com o pré-processamento.
RAM: 32 GB DDR4 3200MHz. A RAM em quantidade suficiente evita que o sistema faça swap (use o SSD como RAM), o que traria uma grande penalidade de performance.
Armazenamento: SSD NVMe de 1 TB. Além de ser rápido, oferece mais espaço para os modelos, logs e o sistema operacional.
Fonte de Alimentação: Uma fonte de 600W – 750W com certificação 80 Plus Bronze (ou melhor) para garantir energia estável para todos os componentes, especialmente a GPU.

Software e Otimizações (Tão importante quanto o hardware!)

Sistema Operacional: Qualquer distribuição Linux estável. Ubuntu 22.04 LTS ou Debian 12 são as escolhas mais populares e com melhor suporte para drivers.
Drivers NVIDIA: Instale sempre os drivers proprietários mais recentes da NVIDIA e o CUDA Toolkit correspondente à versão suportada pelo PaddlePaddle.
PaddlePaddle: Instale a versão do PaddlePaddle compilada com suporte CUDA e cuDNN. Use o comando de instalação preciso do site oficial.
Busyness (Lote): Em vez de processar uma imagem por vez, implemente uma fila que agrupe várias requisições (ex: 4, 8, 16 imagens) e as envie para a GPU em um único lote. Isso aumenta drasticamente a throughput, aproveitando ao máximo a GPU.
Framework de Inferência: Considere usar o Paddle Inference com otimizações ativadas ou até mesmo TensorRT (também da NVIDIA) para acelerar ainda mais a inferência na GPU, conseguindo ganhos de performance adicionais.

Resumo Final

Componente	Configuração Econômica (CPU)	Configuração Recomendada (GPU)
CPU	Intel i7-12700K / AMD R7 5700X	Intel i5-12400 / AMD R5 5600X
GPU	Integrada	NVIDIA RTX 3060 12GB ou superior
RAM	16 GB DDR4	32 GB DDR4
Armazenamento	SSD NVMe 512 GB	SSD NVMe 1 TB
Custo Relativo	Baixo	Médio
Performance Esperada	1-3 segundos/request	< 1 segundo/request
Observação	Latência variável, use modelos leves	Performance consistente e ideal

Conclusão: Para 60 requests por minuto em produção, invista na configuração com GPU (Opção 2). O custo-benefício em termos de performance, consistência e capacidade de escalar para cargas um pouco maiores no futuro é muito superior. A configuração econômica com CPU só é recomendada para ambientes de teste, desenvolvimento ou com restrições orçamentárias extremas.

Perplexity

Para utilizar o Paddle OCR no Linux com uma volumetria de cerca de 60 requests por minuto, a recomendação de hardware inclui considerar o uso de GPU para ganho significativo de desempenho, especialmente em cenários com alta demanda. Paddle OCR oferece suporte para execução com GPU (NVIDIA GPU com CUDA), que requer instalação do PaddlePaddle GPU e drivers compatíveis (CUDA versão recomendada igual ou maior que 11.8).

Requisitos básicos para boa performance com Paddle OCR no Linux:

Processador x86_64 64-bit, preferencialmente com múltiplos núcleos para melhor paralelismo.
Memória RAM mínima recomendada de 6 GB, recomendável 8 GB ou mais para lidar com múltiplas requisições e modelos.
GPU NVIDIA compatível (Ampere ou superior é ideal), com driver e CUDA instalados para usar a aceleração via GPU.
Sistema operacional Linux (distribuições populares suportam bem).
Python 3.9+ e PaddlePaddle (versão 3.0 ou superior).

Por que GPU?

Paddle OCR com GPU processa imagens e textos muito mais rápido que uso somente CPU.
Para 60 requisições por minuto, uma GPU moderna (ex: NVIDIA RTX 3060 ou superior) pode garantir baixa latência e throughput suficiente sem gargalos.
Caso não tenha GPU, recomenda-se CPU potente (multi-core) e otimização no paralelismo, porém desempenho será inferior.

Caso não use GPU

CPU com múltiplos núcleos (especialmente com suporte a AVX2/AVX512) ajuda no desempenho.
Mínimo de 8 GB RAM para evitar swapping em cargas paralelas.

Resumo sugestivo de hardware para 60 req/min Paddle OCR Linux:

Componente	Recomendação
CPU	Intel i7 10a gen ou AMD Ryzen 7 3700X ou superior
GPU	NVIDIA RTX 3060 (CUDA 11.8+) para aceleração
RAM	Mín. 8 GB, ideal 16 GB para margem
Armazenamento	SSD para velocidade de leitura e escrita
Sistema Operacional	Linux 64-bit moderno (ex: Ubuntu 22.04 LTS)

Essa configuração deve permitir o processamento de 60 requisições de OCR por minuto com baixa latência, especialmente com uso de GPU. Para uso exclusivamente via CPU, a capacidade ficará limitada e o desempenho cairá, podendo exigir mais núcleos e RAM.

Se desejar, posso ajudar a detalhar comandos para instalar o PaddleOCR e suas dependências em Linux com suporte a GPU.

Referências:paddlepaddle.github+5

Claude

Para uma solução de OCR com PaddleOCR processando 60 requests por minuto, vou fazer algumas considerações sobre hardware e configuração:

Recomendações de Hardware

Processador (CPU)

Mínimo: Intel i7 8ª geração ou AMD Ryzen 7 (8 cores/16 threads)
Recomendado: Intel i9 ou AMD Ryzen 9 (12+ cores)
O PaddleOCR pode rodar em CPU, mas será mais lento

GPU (Altamente Recomendada)

NVIDIA RTX 3070 ou superior (8GB VRAM mínimo)
RTX 4070/4080 para melhor performance
Para produção: RTX A4000/A5000 ou Tesla T4/V100
CUDA compatibility é essencial para aceleração

Memória RAM

Mínimo: 16GB DDR4
Recomendado: 32GB DDR4/DDR5
PaddleOCR + modelos carregados podem consumir 4-8GB

Armazenamento

SSD NVMe de pelo menos 500GB
Para logs e cache temporário de imagens
RAID 1 para redundância em produção

Rede

Conexão estável de pelo menos 100Mbps
Baixa latência se processar imagens remotas

Estimativas de Performance

Com 60 requests/minuto (1 req/segundo):

Com GPU: 0.1-0.5s por imagem (dependendo do tamanho)
Apenas CPU: 1-3s por imagem

Configurações Linux Recomendadas

Distribuição

Ubuntu 20.04/22.04 LTS (melhor suporte CUDA)
CentOS 8 ou Rocky Linux para ambientes corporativos

Otimizações

# Aumentar limites de arquivo
echo "* soft nofile 65536" >> /etc/security/limits.conf
echo "* hard nofile 65536" >> /etc/security/limits.conf

# Otimizar para GPU
echo "nvidia-persistenced --user nvidia-persistenced" >> /etc/rc.local

Configuração de Instância Sugerida

Para esta volumetria específica, uma configuração balanceada seria:

CPU: AMD Ryzen 7 5700X (8c/16t)
GPU: RTX 3070 Ti (8GB)
RAM: 32GB DDR4
Storage: SSD NVMe 1TB
OS: Ubuntu 22.04 LTS

Essa configuração deve processar confortavelmente 60 requests/minuto com margem para picos de demanda. Você planeja processar que tipos de imagens (documentos, fotos, tamanho médio)?

Qwen

Para rodar PaddleOCR com uma volumetria de 60 requisições por minuto (1 requisição por segundo) em um ambiente Linux, é importante considerar o tipo de OCR (texto simples, tabelas, documentos escaneados, etc.), o tamanho e resolução das imagens, e se você deseja baixa latência ou pode aceitar filas.

Abaixo está uma recomendação de hardware baseada em um cenário realista e escalável, com foco em desempenho estável, eficiência energética e custo-benefício.

🔹 Cenário Assumido

60 imagens por minuto → ~1 imagem por segundo
Imagens: escaneadas ou capturadas com resolução média (300 DPI, A4, ~1-2 MB)
Uso de modelo PP-OCRv4 (recomendado para precisão e velocidade)
Inferência em CPU ou GPU (comparação feita)
Baixa latência desejada (< 1 segundo por imagem)
Sistema operacional: Linux (Ubuntu 20.04/22.04 LTS)

✅ Recomendação de Hardware

Opção 1: Com GPU (Recomendada para baixa latência e escalabilidade futura)

Componente	Recomendação
CPU	Intel Core i7-12700 / AMD Ryzen 7 5700X
RAM	32 GB DDR4/DDR5 (pode ser 16 GB para casos leves)
GPU	NVIDIA RTX 3060 / 4060 / A2000 6GB+
Armazenamento	500 GB NVMe SSD
Sistema	Ubuntu 22.04 LTS

🔧 Por que GPU?

PaddleOCR com modelos grandes (como PP-OCRv4) se beneficia muito de GPU.
GPU acelera inferência em até 5–10x em relação à CPU.
RTX 3060/4060 tem suporte a CUDA e Tensor Cores, essenciais para PaddlePaddle.
Com GPU, você alcança < 300 ms por imagem, mesmo com detecção + reconhecimento.

✅ Com essa configuração, você consegue processar muito mais que 60 RPM, com folga para picos.

Opção 2: Apenas CPU (para ambientes com restrição de orçamento ou virtualizados)

Componente	Recomendação
CPU	Intel Xeon E-23xx / AMD Ryzen 7 5800X (8+ cores)
RAM	32 GB DDR4
Armazenamento	500 GB SSD
Sistema	Ubuntu 22.04 LTS

⚠️ Considerações:

Inferência em CPU com modelos leves (ex: PP-OCRv4 em modo quantizado) leva ~800 ms a 1.5 s por imagem.
Para manter 1 req/s, você precisa de paralelismo (fila + workers).
Use FastAPI + Gunicorn + Uvicorn com múltiplos workers (ex: 4–6) para lidar com concorrência.
Pode haver picos de latência se imagens forem grandes.

❗ Sem GPU, o sistema pode ficar no limite com 60 RPM. Recomenda-se otimização do modelo (quantização, pruning) e fila de tarefas (Redis + Celery).

🔧 Otimizações Recomendadas (Independente do Hardware)

Use modelos quantizados:

# Exemplo: modelo quantizado para CPU
ocr = PaddleOCR(use_angle_cls=True, use_gpu=True, det_model_dir="ch_PP-OCRv4_det_quant", rec_model_dir="ch_PP-OCRv4_rec_quant")

Modelos quantizados reduzem uso de RAM e aumentam velocidade em CPU.

Pré-processamento de imagem:
- Reduza resolução para ~960px na maior dimensão.
- Converta para escala de cinza se possível.
Cache de resultados:
- Se houver repetição de documentos, use cache (Redis).
Orquestração com Docker + FastAPI:
- Containerize a aplicação para fácil deploy e escala.
- Monitore uso de CPU/GPU com nvidia-smi, htop, prometheus.
Escalonamento horizontal (futuro):
- Se volume aumentar, use Kubernetes ou load balancer com múltiplos nós.

📊 Benchmark Estimado (aproximado)

Hardware	Tempo por imagem	Capacidade (RPM)	Latência média
RTX 3060 + i7	~200–400 ms	150–300 RPM	< 0.5 s
Ryzen 7 + CPU	~800–1200 ms	50–70 RPM	~1 s
CPU + modelo quantizado	~500 ms	100–120 RPM	< 0.6 s

✅ Conclusão

Para 60 requisições por minuto com conforto e baixa latência, recomendo:

✅ Sistema com GPU: RTX 3060 / 4060 + 32GB RAM + CPU moderno (i7/Ryzen 7)
✅ Use Ubuntu 22.04, Docker, FastAPI e modelos quantizados do PaddleOCR.

Se orçamento for limitado, use CPU com múltiplos workers e modelo otimizado, mas monitore a latência.

Se quiser, posso te ajudar a montar um Dockerfile ou script de deploy com FastAPI + PaddleOCR.

Azure (NC4as T4 v3) – $0.193 spot instance

https://instances.vantage.sh/azure/vm/nc4ast4-v3?currency=USD

AWS (g4dn.xlarge) – USD 0,210

https://aws.amazon.com/pt/ec2/instance-types/g4/