Storage Corporativo Debian 13 (Trixie) LVM, NFS, iSCSI, ZFS & RAID Integridade & Alta Disponibilidade

Soluções de Storage e Armazenamento no Debian 13

Guia aprofundado de armazenamento local e em rede para servidores Linux: gerenciamento flexível de volumes lógicos com LVM, compartilhamento de arquivos de alta performance com NFSv4, exportação e conexão de blocos remotos com iSCSI Target/Initiator, resiliência avançada e copy-on-write com OpenZFS e tolerância a falhas de hardware com Software RAID (mdadm).

A Pilha de Armazenamento no Linux (Storage Stack)

O gerenciamento de armazenamento em ambientes corporativos Linux é organizado em camadas modulares e complementares. Compreender essa hierarquia é fundamental para projetar infraestruturas resilientes, escaláveis e de alto desempenho:

1. Dispositivos Físicos

Discos brutos NVMe, SSDs SATA/SAS, HDDs mecânicos e LUNs de SANs de fibra (dispositivos de bloco como /dev/nvme0n1 ou /dev/sdb).

2. Redundância & Pools

Agrupamento e tolerância a falhas através de Software RAID (mdadm), LVM2 (PV/VG) ou OpenZFS (VDEVs/Zpools).

3. Sistemas de Arquivos

Estruturação de dados locais com Ext4 (estabilidade madura), XFS (altíssima escalabilidade para arquivos grandes) ou ZFS Datasets.

4. Storage em Rede

Acesso remoto via rede TCP/IP em nível de arquivos compartilhados com NFSv4 ou nível de bloco bruto com iSCSI SAN.

Matriz Comparativa das Tecnologias de Armazenamento
Tecnologia Nível de Abstração Escopo de Conexão Tolerância a Falhas Expansão Dinâmica Melhor Caso de Uso
LVM2 Bloco Lógico (LV) Local Nenhuma (a menos que sobre RAID) Excelente (Online) Sistemas operacionais, partições de SO, particionamento flexível.
NFSv4 Nível de Arquivo (File) Rede (TCP 2049) Depende do Storage subjacente Simples no Servidor Home directories compartilhados, clusters web, storage de containers.
iSCSI Nível de Bloco (LUN) Rede (TCP 3260) Depende do Target/SAN Via LUN Resize Discos virtuais para Proxmox/VMware, bancos de dados em SAN IP.
OpenZFS Bloco + FS Integrados Local (exp. por NFS/SMB) Auto-cura + Mirror/RAIDZ Adição de VDEVs Servidores de arquivos críticos, backup de longo prazo, integridade contra bit rot.
mdadm (RAID) Nível de Bloco (MD) Local Espelho/Paridade (1, 5, 10) Moderada Tolerância a falha de discos mecânicos/SSDs sem controladora RAID cara.
Índice dos Tutoriais de Storage

Navegue diretamente para cada um dos tutoriais práticos deste módulo técnico:

1 Gerenciamento de Volumes LVM (PV, VG, LV)
LVM2 Logical Volume Manager Volumes Dinâmicos, Expansão Online e Snapshots CoW
Fundamentação Teórica

O LVM2 (Logical Volume Manager 2) abstrai o armazenamento físico em uma estrutura hierárquica flexível, superando as limitações rígidas do particionamento tradicional (MBR/GPT). Ele opera em três camadas essenciais:

  • Physical Volume (PV): Discos inteiros (ex: /dev/sdb) ou partições individuais inicializados com cabeçalhos LVM. O LVM divide cada PV em pequenos blocos atômicos chamados Physical Extents (PE), com tamanho padrão de 4 MiB.
  • Volume Group (VG): Um pool de armazenamento unificado resultante do agrupamento de um ou mais PVs. O VG atua como um "disco virtual gigante" de onde o espaço será alocado sob demanda.
  • Logical Volume (LV): Dispositivos de bloco virtuais criados a partir dos PEs disponíveis no VG. Eles são apresentados ao kernel Linux como dispositivos regulares (ex: /dev/vg_dados/lv_arquivos) prontos para receberem sistemas de arquivos.

Vantagens Operacionais Críticas:

  • Expansão Dinâmica Online: É possível estender a capacidade de um Volume Group adicionando novos discos físicos e, em seguida, aumentar o tamanho de um Logical Volume e de seu sistema de arquivos em tempo real, sem desmontar o diretório e sem interromper as aplicações.
  • Snapshots Copy-on-Write (CoW): Permitem capturar o estado exato de um volume lógico em um instante de tempo. Apenas os blocos modificados após o snapshot consomem espaço extra, viabilizando backups consistentes de bancos de dados ativos sem janelas de parada.
  • Comportamento por Sistema de Arquivos: O Ext4 permite expansão online e redução offline (exigindo desmontagem e verificação com e2fsck). Já o XFS suporta apenas expansão online, não permitindo redução de tamanho em hipótese alguma.
Roteiro Prático de Configuração do LVM
terminal — Debian 13
# 1. Instalar o pacote LVM2
sudo apt update && sudo apt install -y lvm2

# 2. Identificar os discos disponíveis para alocação
lsblk -e 7

# 3. Inicializar os discos físicos como Physical Volumes (PVs)
sudo pvcreate /dev/sdb /dev/sdc

# 4. Criar o Volume Group 'vg_dados' unificando os dois discos
sudo vgcreate vg_dados /dev/sdb /dev/sdc

# 5. Criar Volumes Lógicos (LVs) dentro do Volume Group
# Criar lv_arquivos com tamanho fixo de 20 GB
sudo lvcreate -L 20G -n lv_arquivos vg_dados

# Criar lv_banco utilizando 50% do espaço restante no VG
sudo lvcreate -l 50%FREE -n lv_banco vg_dados

# 6. Formatar os volumes lógicos com sistemas de arquivos
sudo mkfs.ext4 /dev/vg_dados/lv_arquivos
sudo mkfs.xfs /dev/vg_dados/lv_banco

# 7. Criar pontos de montagem e montar os volumes
sudo mkdir -p /mnt/arquivos /mnt/banco
sudo mount /dev/vg_dados/lv_arquivos /mnt/arquivos
sudo mount /dev/vg_dados/lv_banco /mnt/banco

# 8. Configurar montagem automática persistente no /etc/fstab
sudo tee -a /etc/fstab << 'END_FSTAB'
/dev/vg_dados/lv_arquivos  /mnt/arquivos  ext4  defaults  0  2
/dev/vg_dados/lv_banco     /mnt/banco     xfs   defaults  0  2
END_FSTAB

# 9. EXPANSÃO DINÂMICA ONLINE (sem desmontar o volume)
# O parâmetro -r redimensiona o sistema de arquivos Ext4 automaticamente
sudo lvextend -L +10G -r /dev/vg_dados/lv_arquivos

# 10. CRIAÇÃO DE SNAPSHOT COPY-ON-WRITE PARA BACKUP
sudo lvcreate -L 5G -s -n snap_arquivos /dev/vg_dados/lv_arquivos
sudo mkdir -p /mnt/backup_snap
sudo mount -o ro /dev/vg_dados/snap_arquivos /mnt/backup_snap
Validação e Verificação
validação — relatórios LVM
# Exibir resumo sucinto de PVs, VGs e LVs
sudo pvs
sudo vgs
sudo lvs

# Verificar a hierarquia de blocos e capacidade expandida
lsblk -f /dev/vg_dados/lv_arquivos
df -hT /mnt/arquivos /mnt/banco
2 Servidor de Arquivos em Rede NFSv4
NFSv4 RFC 7530 / RFC 8881 Porta Única TCP 2049, Pseudo-Filesystem e idmapd
Fundamentação Teórica

O Network File System (NFS) é o padrão nativo para compartilhamento de diretórios em ambientes Unix/Linux. Com a evolução para a versão NFSv4, o protocolo superou as complexidades de firewall e limitações das versões anteriores:

  • Porta Única Padronizada (TCP 2049): O NFSv3 dependia de portas dinâmicas negociadas pelo rpcbind / portmapper (porta 111) e serviços auxiliares (lockd, mountd, statd), tornando as regras de firewall excessivamente complexas. O NFSv4 opera integralmente sobre uma única conexão TCP na porta 2049.
  • Pseudo-Filesystem Raiz: Todas as exportações do servidor são estruturadas sob um diretório raiz virtual unificado (marcado pela diretiva fsid=0 ou fsid=root). O cliente monta essa árvore a partir da raiz lógica, sem precisar conhecer os caminhos físicos reais do disco no servidor.
  • Mapeamento de Identidades com idmapd: Em vez de confiar cegamente nos números de UID e GID transmitidos na rede, o NFSv4 traduz usuários e grupos em cadeias de texto no formato usuario@dominio, mitigando discrepâncias de identificadores numéricos entre clientes e servidores.

Diretivas Chave do Arquivo /etc/exports:

  • rw / ro: Permissão de leitura e escrita ou somente leitura.
  • sync: Garante que alterações sejam gravadas em disco antes de responder ao cliente (essencial para integridade de dados).
  • no_subtree_check: Desativa a verificação de subárvores de diretórios, aumentando a performance e evitando travamentos ao renomear arquivos abertos.
  • root_squash: Transforma o usuário root (UID 0) do cliente no usuário anônimo nobody no servidor, impedindo que um administrador do cliente tenha privilégios de superusuário no storage.
Roteiro Prático: Configuração do Servidor e Cliente NFSv4
terminal — Debian 13 (Servidor NFS)
# 1. Instalar o servidor de kernel NFS
sudo apt update && sudo apt install -y nfs-kernel-server

# 2. Criar a estrutura do Pseudo-Filesystem Raiz (/srv/nfs4)
sudo mkdir -p /srv/nfs4/compartilhado
sudo mkdir -p /dados/arquivos

# 3. Vincular o diretório real ao pseudo-filesystem usando montagem bind
sudo mount --bind /dados/arquivos /srv/nfs4/compartilhado

# Tornar a montagem bind persistente no /etc/fstab do servidor
sudo tee -a /etc/fstab << 'END_FSTAB'
/dados/arquivos  /srv/nfs4/compartilhado  none  bind  0  0
END_FSTAB

# 4. Ajustar permissões para permitir escrita de usuários da rede
sudo chown -R nobody:nogroup /dados/arquivos
sudo chmod -R 777 /dados/arquivos

# 5. Declarar as exportações em /etc/exports
sudo tee /etc/exports << 'END_EXPORTS'
# Raiz do Pseudo-Filesystem NFSv4
/srv/nfs4                 192.168.56.0/24(ro,sync,fsid=0,crossmnt,no_subtree_check)

# Ponto de compartilhamento com permissão de leitura e escrita
/srv/nfs4/compartilhado   192.168.56.0/24(rw,sync,no_subtree_check,root_squash)
END_EXPORTS

# 6. Atualizar a tabela de exportações e reiniciar o serviço
sudo exportfs -arv
sudo systemctl restart nfs-kernel-server

# 7. Liberar a porta 2049/TCP no firewall UFW
sudo ufw allow from 192.168.56.0/24 to any port 2049 proto tcp
terminal — Debian 13 (Cliente NFS)
# 1. Instalar o cliente NFS
sudo apt update && sudo apt install -y nfs-common

# 2. Consultar os compartilhamentos exportados pelo servidor
showmount -e 192.168.56.10

# 3. Montar o compartilhamento NFSv4 (note o caminho relativo à raiz virtual)
sudo mkdir -p /mnt/nfs_dados
sudo mount -t nfs4 192.168.56.10:/compartilhado /mnt/nfs_dados

# 4. Configurar montagem automática resiliente no /etc/fstab do cliente
sudo tee -a /etc/fstab << 'END_FSTAB'
192.168.56.10:/compartilhado  /mnt/nfs_dados  nfs4  _netdev,rw,sync,hard,intr,timeo=600  0  0
END_FSTAB
Validação e Verificação
validação — teste de I/O em rede
# No cliente: criar arquivo de teste no storage
echo "Teste de integridade NFSv4 Debian 13" > /mnt/nfs_dados/teste_io.txt
ls -la /mnt/nfs_dados/teste_io.txt

# No servidor: verificar exportações ativas em tempo real
sudo exportfs -s
3 Configuração de iSCSI Target & Initiator
iSCSI SAN sobre IP (RFC 3720) Exportação de Blocos Brutos, LUNs e Autenticação CHAP
Fundamentação Teórica

O iSCSI (Internet Small Computer Systems Interface) viabiliza redes de área de armazenamento (Storage Area Network - SAN) de baixo custo utilizando a infraestrutura Ethernet e roteamento TCP/IP existente na empresa (porta 3260).

Diferença Fundamental entre NFS e iSCSI:

  • NFS (Nível de Arquivo / NAS): O servidor formata o disco com seu próprio sistema de arquivos (ex: Ext4) e compartilha chamadas de arquivo (abrir, ler, fechar). Os clientes dependem das permissões do servidor.
  • iSCSI (Nível de Bloco / SAN): O servidor disponibiliza apenas os setores brutos de um disco (uma LUN - Logical Unit Number). O cliente enxerga o storage remoto exatamente como se fosse um disco rígido SCSI/SATA conectado fisicamente à sua placa-mãe (ex: /dev/sdb). O próprio cliente é quem particiona e formata o volume com o sistema de arquivos de sua escolha.

Nomenclatura e Componentes Essenciais:

  • Target (Alvo): O servidor que atua como provedor de storage, exportando uma ou mais LUNs.
  • Initiator (Iniciador): O cliente (servidor de banco de dados, nó de virtualização Proxmox ou KVM) que se conecta ao Target para consumir os blocos.
  • IQN (iSCSI Qualified Name): Identificador global exclusivo padronizado no formato: iqn.AAAA-MM.dominio.reverso:identificador_unico.
  • Autenticação CHAP (Challenge-Handshake Authentication Protocol): Garante que apenas iniciadores autorizados consigam estabelecer sessão e montar a LUN.
Roteiro Prático: Configuração do Target e Initiator no Debian 13
terminal — Debian 13 (iSCSI Target - Servidor)
# 1. Instalar o daemon de iSCSI Target (tgt)
sudo apt update && sudo apt install -y tgt

# 2. Criar um arquivo de imagem de 10 GB para servir de backing-store da LUN
sudo mkdir -p /var/iscsi
sudo fallocate -l 10G /var/iscsi/lun01.img

# 3. Configurar a LUN e o IQN em /etc/tgt/conf.d/storage.conf
sudo tee /etc/tgt/conf.d/storage.conf << 'END_CONF'

    # Arquivo ou particao bruta exportada
    backing-store /var/iscsi/lun01.img

    # Controle de acesso por IP do cliente
    initiator-address 192.168.56.0/24

    # Autenticacao CHAP de seguranca
    incominguser iscsiuser SenhaSegura2026!

END_CONF

# 4. Reiniciar o serviço tgt e liberar a porta 3260/TCP
sudo systemctl restart tgt
sudo ufw allow 3260/tcp

# 5. Visualizar o status do Target e das LUNs exportadas
sudo tgt-admin --show
terminal — Debian 13 (iSCSI Initiator - Cliente)
# 1. Instalar o utilitário open-iscsi
sudo apt update && sudo apt install -y open-iscsi

# 2. Descobrir os alvos disponíveis no servidor de storage
sudo iscsiadm -m discovery -t sendtargets -p 192.168.56.10

# 3. Configurar credenciais de autenticação CHAP para o alvo descoberto
sudo iscsiadm -m node -T iqn.2026-09.br.eti.morais:storage.lun1 -o update -n node.session.auth.authmethod -v CHAP
sudo iscsiadm -m node -T iqn.2026-09.br.eti.morais:storage.lun1 -o update -n node.session.auth.username -v iscsiuser
sudo iscsiadm -m node -T iqn.2026-09.br.eti.morais:storage.lun1 -o update -n node.session.auth.password -v SenhaSegura2026!

# 4. Conectar e estabelecer a sessão iSCSI
sudo iscsiadm -m node -T iqn.2026-09.br.eti.morais:storage.lun1 -p 192.168.56.10:3260 --login

# 5. Identificar o novo disco reconhecido pelo kernel (ex: /dev/sdb)
lsblk -o NAME,SIZE,TYPE,TRAN

# 6. Formatar o disco remoto com Ext4 e montar localmente
sudo mkfs.ext4 -F /dev/sdb
sudo mkdir -p /mnt/san_disco
sudo mount /dev/sdb /mnt/san_disco

# 7. Obter o UUID do disco iSCSI e configurar montagem no /etc/fstab
UUID_ISCSI=$(sudo blkid -s UUID -o value /dev/sdb)
# Adicionar com a flag obrigatória '_netdev' (espera a rede subir antes de montar)
echo "UUID=${UUID_ISCSI}  /mnt/san_disco  ext4  _netdev,defaults  0  0" | sudo tee -a /etc/fstab
Validação e Verificação
validação — sessões iSCSI ativas
# Exibir parâmetros detalhados da sessão ativa no cliente
sudo iscsiadm -m session -P 3

# Conferir se o volume está montado e operante
df -hT /mnt/san_disco
4 Implantação de Pools e Datasets ZFS
OpenZFS Copy-on-Write 128-bit Auto-Cura, Checksums Criptográficos e Compressão LZ4
Fundamentação Teórica

O OpenZFS é considerado o sistema de arquivos corporativo mais avançado e resiliente disponível no ecossistema Linux. Ele unifica em uma única camada as funções de gerenciador de volumes lógicos e sistema de arquivos transacional.

Diferenciais Arquiteturais de Alta Confiabilidade:

  • Modelo Transacional Copy-on-Write (CoW): Blocos de dados existentes nunca são sobrescritos no lugar (in-place overwrite). Novas gravações são alocadas em blocos livres e os ponteiros de metadados são atualizados atomicamente. Isso elimina o risco de corrupção do sistema de arquivos após quedas bruscas de energia, dispensando verificações demoradas como fsck.
  • Checksums de Dados e Auto-Cura (Self-Healing): Cada bloco gravado possui uma soma de verificação criptográfica (SHA-256 ou Skein). Durante a leitura ou execução de rotinas de varredura (scrub), se um bloco sofrer deterioração física (silent data corruption ou bit rot), o ZFS detecta a anomalia e repara automaticamente o dado corrompido utilizando a cópia intacta do espelho (mirror) ou da paridade (RAID-Z).
  • Compressão Transparente Inline: Com algoritmos velozes como LZ4 ou ZSTD, os dados são compactados antes de atingir a controladora e descompactados na leitura pela CPU. Como o gargalo do hardware é quase sempre a taxa de transferência do disco, a compressão do ZFS frequentemente aumenta o throughput global de I/O enquanto economiza até 50% de espaço em disco.
  • Licenciamento no Debian: O ZFS foi desenvolvido sob a licença CDDL, juridicamente incompatível com a licença GPL do kernel Linux. Por essa razão, a distribuição Debian disponibiliza o OpenZFS através dos repositórios contrib, onde o módulo é compilado localmente na máquina do administrador via DKMS (Dynamic Kernel Module Support).
Roteiro Prático de Instalação e Administração do ZFS
terminal — Debian 13
# 1. Habilitar o repositório 'contrib' no Debian 13
sudo apt install -y software-properties-common
sudo apt-add-repository contrib
sudo apt update

# 2. Instalar cabeçalhos do kernel e os pacotes OpenZFS com suporte a DKMS
sudo apt install -y linux-headers-amd64 zfsutils-linux zfs-dkms

# 3. Carregar o módulo zfs no kernel
sudo modprobe zfs

# 4. Criar um Storage Pool ZFS espelhado (Mirror - equivalente a RAID 1)
# ashift=12 otimiza para setores de 4 KiB (Advanced Format)
sudo zpool create -o ashift=12 -m /storage pool-dados mirror /dev/sdb /dev/sdc

# 5. Habilitar compressão LZ4 e desativar atualização de atime no pool
sudo zfs set compression=lz4 pool-dados
sudo zfs set atime=off pool-dados

# 6. Criar Datasets hierárquicos com propriedades específicas
sudo zfs create pool-dados/banco
sudo zfs create pool-dados/documentos

# Otimizar tamanho de bloco para banco de dados (ex: InnoDB 16k)
sudo zfs set recordsize=16k pool-dados/banco

# 7. Criar Snapshots instantâneos com custo zero de espaço inicial
sudo zfs snapshot pool-dados/documentos@backup_inicial

# 8. Executar varredura de integridade e auto-cura (Scrubbing)
sudo zpool scrub pool-dados
Validação e Verificação
validação — zpool e zfs
# Verificar a saúde do pool, erros de I/O e status do scrub
sudo zpool status pool-dados

# Listar a taxa de compressão e espaço consumido por dataset
sudo zfs list -o name,used,available,refer,compressratio,mountpoint

# Listar todos os snapshots existentes
sudo zfs list -t snapshot
5 Criação de RAID por Software com mdadm
mdadm Software RAID Redundância de Discos, Reconstrução e Tolerância a Falhas
Fundamentação Teórica

O Software RAID no Linux é fornecido pelo driver de kernel md (Multiple Devices) e administrado através do utilitário padrão mdadm. Ele oferece tolerância à quebra física de discos rígidos e SSDs sem exigir controladoras proprietárias dispendiosas (que geram dependência de fornecedor).

Níveis Comuns de RAID e Características de Projeto:

  • RAID 0 (Striping): Divide os dados em blocos e distribui entre os discos. Oferece alta taxa de leitura e escrita e capacidade de 100% da soma dos discos, mas tem ZERO tolerância a falhas: se um único disco falhar, todos os dados do arranjo são irremediavelmente perdidos.
  • RAID 1 (Mirroring / Espelhamento): Grava cópias perfeitamente idênticas dos dados em dois ou mais discos. Capacidade útil equivalente a apenas 1 disco. Tolerância de falha de N-1 discos e excelente velocidade de leitura paralela. Ideal para discos de sistema operacional e servidores de produção essenciais.
  • RAID 5 (Distributed Parity): Exige no mínimo 3 discos. Os blocos de paridade calculados via algoritmo XOR são distribuídos alternadamente entre todos os membros. Suporta a falha de 1 disco sem perda de dados. Capacidade útil de (N - 1) * tamanho_do_menor_disco.
  • RAID 10 (1+0): Combina o espelhamento do RAID 1 com a distribuição do RAID 0 em um mínimo de 4 discos. Oferece alto desempenho de leitura/escrita e excelente tolerância a falhas (suportando a quebra simultânea de discos em pares espelhados diferentes).
Roteiro Prático: Criação, Montagem e Simulação de Falha
terminal — Debian 13
# 1. Instalar o utilitário mdadm
sudo apt update && sudo apt install -y mdadm

# 2. Criar um arranjo RAID 1 espelhado com os discos /dev/sdb e /dev/sdc
sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/sdb /dev/sdc

# 3. Acompanhar a sincronização inicial dos blocos em tempo real
cat /proc/mdstat

# 4. Formatar o dispositivo de array /dev/md0 com Ext4
sudo mkfs.ext4 -F /dev/md0

# 5. Criar o ponto de montagem e montar o volume
sudo mkdir -p /mnt/raid1
sudo mount /dev/md0 /mnt/raid1

# 6. Salvar a assinatura do array em /etc/mdadm/mdadm.conf para boot persistente
sudo mkdir -p /etc/mdadm
sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf
sudo update-initramfs -u

# 7. Adicionar entrada no /etc/fstab pelo UUID do array
UUID_MD=$(sudo blkid -s UUID -o value /dev/md0)
echo "UUID=${UUID_MD}  /mnt/raid1  ext4  defaults  0  2" | sudo tee -a /etc/fstab

# 8. TESTE DE TOLERÂNCIA A FALHAS E RECUPERAÇÃO DE DISCO:
# Simular falha forçada do disco /dev/sdb
sudo mdadm --manage /dev/md0 --fail /dev/sdb

# Remover o disco "defeituoso" do array
sudo mdadm --manage /dev/md0 --remove /dev/sdb

# Adicionar o disco substituto /dev/sdd para reconstrução automática (rebuild)
sudo mdadm --manage /dev/md0 --add /dev/sdd

# Acompanhar a reconstrução automática pelo kernel
watch -n 1 cat /proc/mdstat
Validação e Verificação
validação — status do RAID
# Inspecionar detalhes de integridade, eventos e estado das unidades
sudo mdadm --detail /dev/md0

# Verificar a saída de dispositivos de bloco
lsblk /dev/md0
Módulo Anterior: Serviços Básicos Próximo Módulo: Virtualização

Privacidade e preferências

Responsável: Nathaniel Simch de Morais. Contato: nathaniel@morais.eti.br.

Preferência essencial: guardamos neste navegador a sua escolha por até 180 dias, para respeitá-la nas páginas deste mesmo endereço. Esse registro não é enviado ao Google.

Estatísticas opcionais: após sua aceitação, o Google Analytics 4 recebe informações de navegação, como páginas visitadas, origem do acesso, interações e informações técnicas do navegador e dispositivo, para produzir relatórios de uso. Utiliza identificadores em cookies, como _ga. Nesta integração, os cookies de análise têm duração configurada de até 180 dias, renovável com o uso autorizado.

A tag de análise não é carregada antes da aceitação nem quando você recusa. As opções de publicidade e personalização de anúncios desta integração permanecem desativadas.

Você pode retirar sua autorização aqui a qualquer momento. A retirada interrompe novas coletas neste navegador e remove os cookies de análise acessíveis a este site; não apaga automaticamente dados já enviados. Para solicitações sobre seus dados, utilize o contato acima.

O Google pode processar dados em servidores fora do seu país. Consulte a Política de Privacidade do Google. Recursos externos utilizados pelas páginas, como bibliotecas e fontes, e os registros técnicos da hospedagem são independentes desta preferência de Analytics.