diff --git a/docs/pt/about/images/market-growth.png b/docs/pt/about/images/market-growth.png new file mode 100644 index 0000000..75172f7 Binary files /dev/null and b/docs/pt/about/images/market-growth.png differ diff --git a/docs/pt/about/images/office-location.png b/docs/pt/about/images/office-location.png new file mode 100644 index 0000000..ecdcd26 Binary files /dev/null and b/docs/pt/about/images/office-location.png differ diff --git a/docs/pt/about/images/vision-values.png b/docs/pt/about/images/vision-values.png new file mode 100644 index 0000000..04ebf53 Binary files /dev/null and b/docs/pt/about/images/vision-values.png differ diff --git a/docs/pt/about/index.md b/docs/pt/about/index.md new file mode 100644 index 0000000..2ea9d33 --- /dev/null +++ b/docs/pt/about/index.md @@ -0,0 +1,47 @@ +# Sobre nós + +**A missão do RustFS é tornar-se uma empresa líder mundial em segurança de dados e redução de custos de armazenamento.** + +Somos uma organização open source de armazenamento (Beijing Hengheshake Technology Co., Ltd.), composta por arquitetos de armazenamento experientes vindos de empresas como Baidu, Tencent e TAL. A sede localiza-se em Pequim, China. Os nossos valores: integridade, foco e simplicidade. + +A nossa visão é fornecer ao mundo um produto de armazenamento de objetos distribuído, seguro e económico, com suporte multilíngue. + +O RustFS trabalha continuamente para garantir segurança e reduzir custos de armazenamento em IA, big data, vídeo, computação em nuvem, armazenamento encriptado, manufatura/industrial, cloud‑native e backup de dados. + +Ajudando na globalização do armazenamento humano, sempre em frente... + +## A nossa visão e valores + +### Visão + +Segurança e redução de custos para os dados de toda a humanidade + +### Valores + +Integridade, foco, simplicidade + +![Visão e valores](./images/vision-values.png) + +## Endereço do escritório + +📍 **Endereço** +Parque de Ciência e Tecnologia Zhongguancun Dongsheng, Zona C (Beijing, Haidian, Xixiaokou Rd 66) + +📞 **Telefone** +400-033-5363 + +📧 **E‑mail** + + +![Ambiente de escritório](./images/office-location.png) + +## RustFS fornece armazenamento distribuído seguro e fiável para o mundo + +![Crescimento do mercado de armazenamento de dados](./images/market-growth.png) + +> Segundo a Fortune Business Insights, o mercado global de armazenamento de dados deverá crescer de 218,33 mil milhões USD (2024) para 774 mil milhões USD (2032), com CAGR de 17,1%. + +### Invista no RustFS + +📧 **Contato** + diff --git a/docs/pt/architecture.md b/docs/pt/architecture.md new file mode 100644 index 0000000..730f7cc --- /dev/null +++ b/docs/pt/architecture.md @@ -0,0 +1,40 @@ +--- +title: "Arquitetura do RustFS" +description: "Introdução à arquitetura do RustFS" +--- + +# Arquitetura do RustFS + +O RustFS é um sistema de armazenamento de objetos, semelhante ao conhecido AWS S3. Como alternativa ao MinIO, o RustFS inspira‑se numa arquitetura simples, leve, escalável e elegante. + +Os objetos podem ser documentos, vídeos, PDFs, etc. Para os armazenar, o MinIO oferece uma solução escalável, flexível e eficiente para armazenar, aceder e gerir dados. A compatibilidade com a API do AWS S3 permite integração transparente com aplicações que já falam S3. + +Diagrama de arquitetura: + +![Arquitetura do RustFS](./images/s2-1.png) + +Esta é a arquitetura básica do RustFS. O cluster distribuído utiliza múltiplos nós para executar um objetivo comum. Os nós comunicam entre si através da rede. + +## Modelo de consistência + +Em modos distribuído e single‑node, todas as operações de leitura/escrita seguem estritamente o modelo de consistência read‑after‑write. + +## Conceitos importantes no RustFS + +- Object (objeto): a unidade básica armazenada (ficheiro, fluxo de bytes, etc.) +- Bucket: espaço lógico que contém objetos; para o cliente equivale a uma pasta de topo +- Drive (disco): dispositivo físico onde os dados são gravados +- Set (conjunto): grupo de drives; os objetos são distribuídos por sets via hashing determinístico + +Boas práticas de desenho/planeamento: + +1. Um objeto reside num único Set +2. Um cluster é particionado em múltiplos Sets +3. O número de Drives por Set é fixo e determinado pelo tamanho do cluster +4. Drives de um mesmo Set devem estar, se possível, em nós distintos + +## Agradecimentos + +Arquiteturas tradicionais exigem Master/MetaData/Data Nodes, aumentando a complexidade de deployment e risco de perda de metadados. No RustFS, todos os nós são de mesmo nível, simplificando o desenho e evitando pontos únicos de falha. + +O RustFS adota princípios de arquitetura semelhantes ao MinIO. Agradecemos à comunidade MinIO por promover o S3 e democratizar o acesso ao armazenamento de objetos. diff --git a/docs/pt/comparison.md b/docs/pt/comparison.md new file mode 100644 index 0000000..4474857 --- /dev/null +++ b/docs/pt/comparison.md @@ -0,0 +1,52 @@ +--- +title: RustFS vs. outros produtos de armazenamento +description: Comparação do RustFS com soluções de armazenamento de objetos populares +--- + +# RustFS vs. outros produtos de armazenamento + +| Parâmetro | Ceph | MinIO | RustFS | +| - | - | - | - | +| Linguagem | C++ | Go | Rust | +| Licença | GPL-2.0, LGPL-2.1, LGPL-3.0 | AGPL-3.0 | Apache-2.0 | +| Meta‑data centralizada | √ | x | x | +| Bloco | √ | x | x | +| Ficheiro | √ | x | x | +| Arquitetura | Re‑arquitetura pesada | Leve | Leve | +| Comunidade | √ | √ | √ | +| Amizade de licença | Média | Fraca | Boa | +| Desempenho | Depende de hardware/config | Alta performance/baixa latência | Alta performance/baixa latência | +| Protocolos | S3, RBD, CephFS, etc. | S3 | S3 | +| Dificuldade de uso | Alta | Baixa | Baixa | +| Escala | EB | EB | EB | +| Requisitos HW | Elevado | Médio | Baixo | +| Estabilidade memória | Estável | Oscila em alta concorrência | Estável | +| Expansão | Difícil | Fácil | Fácil | +| Rebalanceamento | Alto consumo | Baixo consumo | Baixo consumo | +| Suporte comercial | √ | √ | √ | + +## Escolas de arquitetura de objeto + +Globalmente há dois estilos: + +1. Com meta‑data centralizada (ex.: Ceph) +2. Sem meta‑data centralizada (ex.: RustFS e MinIO) + +Comparação: + +| Característica | Com meta‑data | Sem meta‑data | +| - | - | - | +| Arquitetura | Servidor central para meta‑dados | Meta‑dados distribuídos nos nós | +| Gestão de meta‑dados | Centralizada e rápida | Distribuída, evita gargalos | +| Ponto único de falha | Possível no servidor de meta‑dados | Eliminado | +| Complexidade de deploy | Elevada, requer operação especializada | Mais simples, nativo de cloud/conteiner | +| Desempenho | Servidor de meta‑dados pode ser gargalo | Pequenos ficheiros consomem mais IOPS | +| Cenários típicos | FS (Lustre, CephFS) com meta‑dados ricos | Objeto (RustFS, MinIO) e larga escala | + +## Sobre performance + +RustFS e MinIO partilham desenho semelhante; o débito depende da rede e discos. Em testes, o RustFS atinge ~323 GB/s leitura e ~183 GB/s escrita. + +Em configurações equivalentes, superam Ceph em velocidade. + + diff --git a/docs/pt/concepts/availability-and-resiliency.md b/docs/pt/concepts/availability-and-resiliency.md new file mode 100644 index 0000000..3b81bcf --- /dev/null +++ b/docs/pt/concepts/availability-and-resiliency.md @@ -0,0 +1,138 @@ +--- +title: "Disponibilidade e escalabilidade" +description: "Descrição técnica de expansão do RustFS e notas de disponibilidade" +--- + +# Disponibilidade e escalabilidade + +## Visão geral de expansão + +O RustFS suporta scale‑out adicionando novos Server Pools. Cada novo pool deve cumprir: + +1. Hostnames contínuos dentro do pool (ex.: node5‑node8) +2. Mesma especificação de discos no pool (tipo/capacidade/quantidade) +3. Sincronização de tempo e conectividade de rede com o cluster existente + +![Arquitetura do RustFS](./images/s2-1.png) + +--- + +## 1) Preparação antes de expandir + +### 1.1 Planeamento de hardware + +| Item | Mínimo | Recomendado produção | +|---|---|---| +| Nº nós | 4 nós/pool | 4‑8 nós/pool | +| RAM por nó | 128 GB | 128 GB | +| Tipo de disco | SSD | NVMe SSD | +| Capacidade por disco | ≥1 TB | ≥4 TB | +| Rede | 10 Gbps | 25 Gbps | + +### 1.2 Verificações de sistema + +```bash +# Hostnames contínuos (ex. nós novos) +cat /etc/hosts +192.168.10.5 node5 +192.168.10.6 node6 +192.168.10.7 node7 +192.168.10.8 node8 + +# Estado de sincronização de tempo +timedatectl status | grep synchronized + +# Firewall (abrir 7000/7001 em todos os nós) +firewall-cmd --list-ports | grep 7000 +``` + +--- + +## 2) Passos de implementação + +### 2.1 Configuração base nos novos nós + +```bash +# Utilizador dedicado (em todos os novos nós) +groupadd rustfs-user +useradd -M -r -g rustfs-user rustfs-user + +# Diretórios de dados (ex.: 8 discos) +mkdir -p /data/rustfs{0..7} +chown -R rustfs-user:rustfs-user /data/rustfs* +``` + +### 2.2 Instalar o serviço RustFS + +```bash +# Binário (versão deve igualar ao cluster) +wget https://dl.rustfs.com/rustfs/v2.3.0/rustfs -O /usr/local/bin/rustfs +chmod +x /usr/local/bin/rustfs + +# Configuração (/etc/default/rustfs) +cat < /etc/default/rustfs +RUSTFS_ROOT_USER=admin +RUSTFS_ROOT_PASSWORD=YourSecurePassword +RUSTFS_VOLUMES="/data/rustfs{0...7}" +RUSTFS_ADDRESS=":7000" +RUSTFS_CONSOLE_ADDRESS=":7001" +EOF +``` + +### 2.3 Expandir o cluster + +```bash +# Atualizar configuração nos nós existentes (adicionar novo pool) +sed -i '/RUSTFS_VOLUMES/s|"$| http://node{5...8}:7000/data/rustfs{0...7}"|' /etc/default/rustfs + +# Reinício simultâneo em todos os nós +systemctl restart rustfs.service +``` + +--- + +## 3) Validação pós‑expansão + +### 3.1 Estado do cluster + +```bash +# Nós adicionados +curl -s http://node1:7001/cluster/nodes | jq .poolMembers + +# Distribuição de pools +rc admin info cluster +``` + +### 3.2 Balanceamento de dados + +```bash +# Proporções de distribuição (esperado próximo da capacidade de cada pool) +watch -n 5 "rustfs-admin metrics | grep 'PoolUsagePercent'" +``` + +--- + +## 4) Notas + +1. Proibido rolling‑restart: reinicie todos os nós em simultâneo +2. Planeie expansão antes de 70% de utilização +3. Tuning recomendado: + +```bash +# Kernel (em todos os nós) +echo "vm.swappiness=10" >> /etc/sysctl.conf +echo "net.core.somaxconn=32768" >> /etc/sysctl.conf +sysctl -p +``` + +--- + +## 5) Troubleshooting + +| Sintoma | Verificar | Comando | +|---|---|---| +| Novo nó não entra | Porta 7000 reachability | `telnet node5 7000` | +| Distribuição desigual | Configuração de pools | `rustfs-admin rebalance start` | +| Estado anómalo na consola | Sincronização de tempo | `chronyc sources` | + +> Nota: baseado na última versão do RustFS. Faça backup completo antes de expandir. Em produção, recomenda‑se revisão por engenheiro de suporte RustFS. diff --git a/docs/pt/concepts/erasure-coding.md b/docs/pt/concepts/erasure-coding.md new file mode 100644 index 0000000..0ca9e92 --- /dev/null +++ b/docs/pt/concepts/erasure-coding.md @@ -0,0 +1,145 @@ +--- +title: "Princípios do Erasure Coding" +description: "O RustFS aplica de forma profunda o código Reed‑Solomon (Erasure Coding) para obter alta confiabilidade e eficiência de armazenamento." +--- + +# Princípios do Erasure Coding + +## 1. Algoritmo central e cenários de aplicação + +O código de Reed‑Solomon (RS) é um tipo de Erasure Code baseado em campos finitos, conhecido pela alta capacidade de recuperação de dados e pela flexibilidade de configuração de redundância. É amplamente usado em: + +### 1.1. Armazenamento distribuído (ex.: RustFS) +- **Fragmentação de dados e redundância** + Divide‑se o dado original em `k` fragmentos e geram‑se `m` fragmentos de paridade (total `n = k + m`). É possível recuperar o dado se até `m` fragmentos forem perdidos. + **Exemplo**: uma política RS(10,4) tolera perda simultânea de 4 nós (utilização 71%), economizando ~50% de espaço em relação a três réplicas (33%). + +- **Recuperação de falhas** + Recostrução por eliminação gaussiana ou FFT a partir dos fragmentos sobreviventes; o tempo de recuperação é inversamente proporcional à largura de banda. + +- **Ajuste dinâmico** + Suporta ajustar `(k,m)` em runtime para adequar níveis de confiabilidade (dados quentes/mornos/frios). + +### 1.2. Comunicação +- **Comunicação via satélite** + RS(255,223) em cenários de alto atraso e alto BER (ex.: NASA), com capacidade de correção de 16 bytes por codeword. + +- **Padrão 5G NR** + RS combinado com CRC em canais de controle para transmissão confiável. + +- **Redes de sensores sem fio** + RS(6,2) para mitigar perdas acumuladas em múltiplos saltos, tolerando ~33% de perda. + +### 1.3. Armazenamento de mídia digital +- **QR Code** + Níveis de tolerância a erros (L 7%, M 15%, Q 25%, H 30%), permitindo decodificação mesmo com danos parciais. + +- **Blu‑ray** + Combina RS(248,216) com entrelaçamento cruzado para corrigir erros em rajada. + +- **Armazenamento em DNA** + RS em cadeias sintéticas para resistir a erros de síntese/sequenciamento (ex.: RS(4,2) em pesquisas da Microsoft). + +## 2. Conceitos básicos de EC + +### 2.1 Evolução da redundância de armazenamento +```rust +// Armazenamento tradicional com três réplicas +let data = "object_content"; +let replicas = vec![data.clone(), data.clone(), data.clone()]; +``` +A abordagem multi‑réplica tem baixa eficiência (33%). EC divide e adiciona paridade para equilibrar eficiência e confiabilidade. + +### 2.2 Parâmetros +- **k**: número de fragmentos de dados +- **m**: número de fragmentos de paridade +- **n**: total de fragmentos (n = k + m) +- **limiar de recuperação**: quaisquer k fragmentos recuperam o dado + +| Esquema | Redundância | Tolerância a falhas | +|--------|-------------|---------------------| +| 3 réplicas | 200% | 2 nós | +| RS(10,4) | 40% | 4 nós | + +## 3. Fundamentos matemáticos de RS + +### 3.1 Construção do campo finito (Galois Field) +Usa‑se GF(2^8) com 256 elementos, satisfazendo: +```math +α^8 + α^4 + α^3 + α^2 + 1 = 0 +``` +Polinómio gerador `0x11D` (binário `100011101`). + +### 3.2 Matriz de codificação +Matriz de Vandermonde (k=2, m=2): +```math +G = \begin{bmatrix} +1 & 0 \\ +0 & 1 \\ +1 & 1 \\ +1 & 2 +\end{bmatrix} +``` + +### 3.3 Processo de codificação +Vetor de dados D = [d₁, d₂, ..., d_k] +Resultado C = D × G + +Interpolação pelo polinómio gerador: +```math +p(x) = d_1 + d_2x + ... + d_kx^{k-1} +``` +Cálculo dos valores de paridade: +```math +c_i = p(i), \quad i = k+1,...,n +``` + +## 4. Implementação no RustFS + +### 4.1 Estratégia de fragmentação +```rust +struct Shard { + index: u8, + data: Vec, + hash: [u8; 32], +} + +fn split_data(data: &[u8], k: usize) -> Vec { + // Implementação da lógica de fragmentação +} +``` +- Tamanho de fragmento dinâmico (64 KB‑4 MB) +- Hash Blake3 para verificação + +### 4.2 Otimizações de codificação paralela +```rust +use rayon::prelude::*; + +fn rs_encode(data: &[Shard], m: usize) -> Vec { + data.par_chunks(k).map(|chunk| { + // Multiplicação matricial acelerada com SIMD + unsafe { gf256_simd::rs_matrix_mul(chunk, &gen_matrix) } + }).collect() +} +``` +- Paralelismo com Rayon +- Operações no campo finito otimizadas com AVX2 + +### 4.3 Fluxo de recuperação (decoding) +```mermaid +sequenceDiagram + Client->>Coordinator: Pedido de leitura de dados + Coordinator->>Nodes: Consultar estado dos fragmentos + alt Fragmentos suficientes disponíveis + Nodes->>Coordinator: Retornar k fragmentos + Coordinator->>Decoder: Iniciar decodificação + Decoder->>Client: Retornar dados originais + else Fragmentos insuficientes + Coordinator->>Repairer: Acionar reparo + Repairer->>Nodes: Recolher fragmentos vivos + Repairer->>Decoder: Reconstrução de dados + Decoder->>Nodes: Escrever novos fragmentos + end +``` + + diff --git a/docs/pt/concepts/glossary.md b/docs/pt/concepts/glossary.md new file mode 100644 index 0000000..69758a5 --- /dev/null +++ b/docs/pt/concepts/glossary.md @@ -0,0 +1,8 @@ +--- +title: "Glossário do RustFS" +description: "Termos essenciais e conceitos do RustFS (versão resumida)" +--- + +# Glossário do RustFS + +Esta página reunirá os principais termos e conceitos relacionados com o RustFS (objetos, buckets, metadados, chaves de acesso, versão, ciclo de vida, etc.). A versão completa será publicada em breve em português. \ No newline at end of file diff --git a/docs/pt/concepts/images/s2-1.png b/docs/pt/concepts/images/s2-1.png new file mode 100644 index 0000000..be0d98e Binary files /dev/null and b/docs/pt/concepts/images/s2-1.png differ diff --git a/docs/pt/concepts/limit.md b/docs/pt/concepts/limit.md new file mode 100644 index 0000000..a38ede1 --- /dev/null +++ b/docs/pt/concepts/limit.md @@ -0,0 +1,70 @@ +--- +title: "Limites de utilização" +description: "RustFS é um armazenamento de objetos simples, eficiente e distribuído. 100% compatível com S3, em licença Apache 2.0." +--- + +# Limites de utilização + +## 1) Limites da API S3 + +> Os seguintes valores seguem o padrão do protocolo S3. + +| Item | Especificação | +| --------------------- | ---------------------------------- | +| Tamanho máximo de objeto | 5 TiB | +| Tamanho mínimo de objeto | 0 B | +| Tamanho máx. por PUT | Upload simples: 500 GiB; Multipart: 5 TiB | +| Nº máx. de partes por upload | 10,000 | +| Faixa de tamanho de parte | 5 MiB a 5 GiB; última parte 0 B a 5 GiB | +| Máx. de partes por listagem | 10,000 | +| Máx. de objetos por listagem | 1,000 | +| Máx. de uploads multipart por listagem | 1,000 | +| Máx. comprimento de nome de bucket | 63 caracteres | +| Máx. comprimento de chave de objeto | 1024 caracteres | +| Máx. comprimento de cada segmento (separado por `/`) | 255 caracteres | +| Máx. versões por objeto | 10,000 (configurável) | + +--- + +## 2) Limites de Erasure Coding (EC) + +> Parâmetros EC devem seguir a configuração baseada na matriz Reed‑Solomon. Considere a parametrização efetiva em produção. + +| Item | Especificação | +| ---------------------------- | ------------------------------ | +| Nº máx. de servidores por cluster | Sem limite | +| Nº mín. de servidores | 1 | +| Quando há 1 servidor: nº mín. de drives | 1 (single‑node/drive, sem redundância) | +| Quando há ≥2 servidores: nº mín. de drives por servidor | 1 | +| Nº máx. de drives por servidor | Sem limite | +| Quórum de leitura | N/2 | +| Quórum de escrita | (N/2) + 1 | + +--- + +## 3) Restrições de nomenclatura de objetos + +### Sistema de ficheiros e SO + +Os nomes de objetos no RustFS estão sujeitos às restrições do SO/sistema de ficheiros subjacente. Por exemplo, no Windows e noutros sistemas, certos caracteres especiais são proibidos: `^`, `*`, `|`, `\`, `/`, `&`, `"` ou `;`. + +Consulte a documentação do seu SO e FS para a lista completa de restrições. + +Para produção, recomenda‑se Linux com XFS para melhor desempenho e compatibilidade. + +### Conflitos de nomes + +Aplicações devem garantir chaves únicas sem conflito. Evite criar objetos cujo nome conflite com prefixos existentes. Quando ocorre conflito, uma operação LIST no caminho em conflito retornará conjunto vazio. + +Exemplo de conflitos: + +```bash +PUT data/hello/2025/first/a.csv +PUT data/hello/2025/first # conflita com prefixo existente + +PUT data/hello/2025/first/ +PUT data/hello/2025/first/vendors.csv # conflita com objeto existente +``` + +Embora GET/HEAD possam funcionar sobre objetos específicos, conflitos farão a LIST em `hello/2025/first/` retornar vazio. + diff --git a/docs/pt/concepts/object-healing.md b/docs/pt/concepts/object-healing.md new file mode 100644 index 0000000..d81a43e --- /dev/null +++ b/docs/pt/concepts/object-healing.md @@ -0,0 +1,64 @@ +--- +title: "Verificação e auto‑recuperação de objetos" +description: "Design e princípios da self‑healing no RustFS em ambiente single‑server multi‑disk" +--- + +# Verificação e auto‑recuperação de objetos + +## Visão geral + +## Arquitetura do RustFS e design de auto‑recuperação + +### Arquitetura single‑server multi‑disk + +O RustFS organiza múltiplos discos como um pool lógico. Objetos são divididos em shards de dados e de paridade (erasure coding) e distribuídos por discos distintos para fiabilidade e desempenho. + +### Princípios de self‑healing + +1. Verificação de integridade por checksum durante leitura (semelhante a ZFS) +2. Redundância por erasure coding para reconstrução quando partes se perdem/corrompem +3. Disparos multi‑nível: online na leitura, scanner de fundo e gatilho manual + +## Princípios de auto‑recuperação + +### Verificação e erasure + +Durante escrita, objetos são particionados em `k` shards de dados e `m` de paridade (total `n=k+m`). Na leitura, shards em falta são reconstruídos a partir dos restantes. + +### Scrub & Repair + +Executa varrimento leve (comparação de metadados/tamanhos) e profundo (leitura bit‑a‑bit com checksum) para detetar e corrigir bit rot. Ao detetar inconsistências, aciona Repair para reconstruir shards e reescrevê‑los. + +## Fluxos de self‑healing + +### Auto‑recuperação online em leitura + +1) Se todos os shards estão íntegros, retorna dados +2) Se há perda/corrupção, reconstrói com shards redundantes e devolve objeto completo + +### Auto‑recuperação por scanner de fundo + +O scanner percorre 1/1024 dos objetos por hashing, executa verificações periódicas e dispara reconstrução quando necessário. Por omissão, o deep scrub fica desativado (pode ser ligado sob demanda). + +### Gatilho manual + +```bash +rc admin heal start --all +``` + +Varre todo o pool e verifica/repara integralmente. Consome recursos; use em janelas de baixa atividade. + +## Exemplos + +```bash +# Estado de self‑healing +rc admin heal status +# Auto‑recuperar apenas um bucket +rc admin heal start --bucket photos +# Parar tarefa em execução +rc admin heal stop +``` + +## Sumário + +A self‑healing do RustFS combina práticas de MinIO, Ceph e ZFS e, com múltiplos gatilhos e verificação/repair, lida eficazmente com shards danificados, falhas de disco e bit rot em cenários single‑node/multi‑node, garantindo alta fiabilidade e disponibilidade. diff --git a/docs/pt/concepts/object-scanner.md b/docs/pt/concepts/object-scanner.md new file mode 100644 index 0000000..ad68931 --- /dev/null +++ b/docs/pt/concepts/object-scanner.md @@ -0,0 +1,33 @@ +--- +title: "Scanner de objetos" +description: "Design do scanner de objetos do RustFS, integração com EC, monitorização e troubleshooting" +--- + +# Scanner de objetos + +Este documento descreve o design e a implementação do scanner de objetos do RustFS, cobrindo a integração com Erasure Coding, mecanismos de Scrub & Repair, estratégia de escalonamento, métricas e troubleshooting. + +## Visão geral + +O scanner de objetos está embutido no motor de armazenamento e verifica periodicamente a integridade dos objetos, executando ações programadas. +As tarefas incluem estatísticas de uso de disco, avaliação de regras de ciclo de vida, replicação e acionamento de auto‑recuperação para objetos corrompidos. + +## Arquitetura e princípios de design + +### Arquitetura do scanner + +O scanner usa amostragem por hash: para cada 1024 objetos, seleciona 1 para verificação, mitigando impacto em tráfego normal. +Integra‑se profundamente com o módulo de Erasure Coding: ao detetar perda/corrupção de partes, reconstrói online usando redundância, garantindo alta disponibilidade e consistência. + +## Verificação e recuperação de dados + +A verificação pode comparar metadados e tamanhos, e fazer leitura bit‑a‑bit para detetar bit rot. Quando necessário, o scanner aciona o fluxo de reparo. + +## Modos de varrimento e agendamento + +Três modos: verificação online em leitura, varrimento periódico em segundo plano e varrimento total manual—equilibrando performance e confiabilidade. +Semelhante ao `osd_scrub_begin_hour` no Ceph, administradores podem configurar janelas e frequência (ex.: verificação leve diária). + +## Monitorização e métricas + +Expõe contagem total de tarefas, falhas e distribuição de duração; publica métricas Prometheus como `rustfs_scanner_jobs_total`, `rustfs_scanner_failures_total`, `rustfs_scanner_duration_seconds`. Alarmes podem ser definidos com base em taxa de falhas e duração. \ No newline at end of file diff --git a/docs/pt/failure/driver.md b/docs/pt/failure/driver.md new file mode 100644 index 0000000..be7c19d --- /dev/null +++ b/docs/pt/failure/driver.md @@ -0,0 +1,149 @@ +--- +title: "Falha de disco" +description: "Com EC, o RustFS mantém acesso durante falhas parciais de discos e realiza auto‑healing após substituição." +--- + +O RustFS, via Erasure Coding, mantém leitura/escrita mesmo com falhas parciais e executa healing após troca de disco. + +--- + +### Índice + +1. [Desmontar o disco com falha](#1-desmontar-o-disco-com-falha) +2. [Substituir o disco com falha](#2-substituir-o-disco-com-falha) +3. [Atualizar `/etc/fstab` ou configuração do RustFS](#3-atualizar-etcfstab-ou-configuração-do-rustfs) +4. [Remontar o novo disco](#4-remontar-o-novo-disco) +5. [Acionar e monitorizar o healing](#5-acionar-e-monitorizar-o-healing) +6. [Verificações finais e notas](#6-verificações-finais-e-notas) + +--- + +### 1) Desmontar o disco com falha + +Desmonte com segurança no SO antes de trocar fisicamente, evitando erros de I/O. + +```bash +# Supondo /dev/sdb +umount /dev/sdb +``` + +> Nota +> +> - Se houver múltiplos pontos de montagem, execute `umount` em cada um +> - Se “device is busy”, pare o serviço RustFS: +> +> ```bash +> systemctl stop rustfs +> ``` + +--- + +### 2) Substituir o disco com falha + +Após trocar fisicamente, particione/formatte e aplique o mesmo rótulo do disco antigo. + +```bash +# Formatar ext4 com label DISK1 (igual ao original) +mkfs.ext4 /dev/sdb -L DISK1 +``` + +> Requisitos +> +> - Capacidade do novo disco ≥ anterior +> - Tipo de FS igual aos demais +> - Prefira montar por LABEL/UUID para resistir a reorder após reboot + +--- + +### 3) Atualizar `/etc/fstab` ou configuração do RustFS + +Garanta que LABEL/UUID no `fstab` apontem para o novo disco. Se usar config específica (ex.: `config.yaml`), atualize também. + +```bash +# Ver fstab +cat /etc/fstab + +# Exemplo de entrada (sem alterações se LABEL igual) +LABEL=DISK1 /mnt/disk1 ext4 defaults,noatime 0 2 +``` + +> Dicas +> +> - Para usar UUID: +> +> ```bash +> blkid /dev/sdb +> # copie o UUID para o fstab +> ``` +> - Valide sintaxe do fstab: +> +> ```bash +> mount -a # sem erro => OK +> ``` + +--- + +### 4) Remontar o novo disco + +Monte e inicie o RustFS: + +```bash +mount -a +systemctl start rustfs +``` + +Confirme as montagens: + +```bash +df -h | grep /mnt/disk +``` + +> Atenção +> +> - Se alguma montagem falhar, verifique fstab e LABEL/UUID + +--- + +### 5) Acionar e monitorizar o healing + +O RustFS aciona healing automático/manual. Exemplo com uma ferramenta hipotética `rustfs-admin`: + +```bash +# Estado dos discos +rustfs-admin disk status + +# Acionar healing no novo disco +rustfs-admin heal --disk /mnt/disk1 + +# Acompanhar progresso +rustfs-admin heal status --follow +``` + +Verifique logs do serviço: + +```bash +# Em instalações geridas por systemd +journalctl -u rustfs -f + +# Ou ficheiro dedicado +tail -f /var/log/rustfs/heal.log +``` + +> Notas +> +> - Healing roda em background e afeta pouco os acessos +> - Ao concluir, a ferramenta reporta sucesso ou objetos pendentes + +--- + +### 6) Verificações finais e notas + +1. Monitorização de performance + - I/O pode oscilar; monitore disco e rede +2. Falhas em lote + - Se vários discos falharem no mesmo lote, aumente inspeções preventivas +3. Exercícios periódicos + - Simule falhas para treinar a equipa +4. Janela de manutenção + - Se a taxa de falha aumentar, planeie janelas para acelerar substituição e healing + diff --git a/docs/pt/failure/node.md b/docs/pt/failure/node.md new file mode 100644 index 0000000..ae0f1e9 --- /dev/null +++ b/docs/pt/failure/node.md @@ -0,0 +1,90 @@ +--- +title: "Falha de nó" +description: "Passos completos para lidar com falha de nó num cluster RustFS: preparação de hardware de substituição, atualização de config, implantação do serviço, reentrada no cluster, healing e verificação." +--- + +# Falha de nó + +Num cluster RustFS distribuído, o Erasure Coding garante leitura/gravação mesmo com falhas parciais de nós e executa auto‑healing quando o nó retorna. Este guia cobre: + +1. Iniciar o nó de substituição e alinhar o ambiente +2. Atualizar DNS/hostname para apontar o identificador antigo para o novo nó +3. Descarregar e implantar a mesma versão do RustFS usada no cluster +4. Reingressar o nó no cluster e acionar o healing +5. Monitorizar o progresso e realizar verificações pós‑recuperação + +## 1) Iniciar o nó de substituição + +- Hardware e SO + Mantenha CPU/memória/rede/discos similares ao nó antigo (maior não prejudica). Alinhe versões de SO/kernel/libs para evitar inconsistências. + +- Acesso exclusivo aos discos + Garanta acesso exclusivo aos volumes de dados; nenhum outro processo deve escrever neles, evitando corrupção ou perda de redundância. + +## 2) Atualizar hostname e resolução + +- DNS/Hosts + Se IP mudou, mapeie o hostname antigo (ex.: `rustfs-node-2.example.net`) para o novo IP. + + ```bash + # Ex.: ajustar /etc/hosts + 192.168.1.12 rustfs-node-2.example.net + ``` + + Valide com `ping` ou `nslookup`. + +## 3) Implantar e configurar o serviço RustFS + +- Download e instalação + Instale a mesma versão usada nos demais nós. Garanta scripts, variáveis e configs (ex.: `/etc/default/rustfs`) alinhados. + +- Verificação de configuração + - Revise endpoints no `config.yaml` (ou ficheiro equivalente) incluindo hostname/porta do novo nó + - Replique credenciais e permissões para evitar falhas de autenticação + +## 4) Reingressar no cluster e acionar healing + +- Iniciar serviço + + ```bash + systemctl start rustfs-server + ``` + + Siga logs (`journalctl -u rustfs-server -f`) para confirmar descoberta de pares e início do healing. + +- Monitorização manual + + ```bash + # Estado do cluster + rc cluster status + + # Acionar healing do nó + rc heal --node rustfs-node-2.example.net + + # Acompanhar progresso + rc heal status --follow + ``` + + O comando `heal` (equivalente a `rc admin heal`) assegura reconstrução de fragmentos perdidos/inconsistentes. + +- Nota de campo + Em testes de comunidade, após retorno de nó offline, o RustFS foca healing apenas no nó novo, evitando rebalanceamento completo. + +## 5) Pós‑verificações e boas práticas + +- Monitorização e alertas + - Observe carga de disco e rede durante o healing + - Configure alertas para falhas/estagnação de progresso + +- Exercícios de DR + Simule falhas periodicamente para treinar a equipa no procedimento + +- Análise de causa raiz + Para falhas frequentes, inspecione saúde de hardware (SMART, BIOS logs) e planeie manutenção preventiva + +- Suporte profissional + Para diagnósticos avançados, contate a equipa do RustFS ou a comunidade + +--- + +Resumo: estes passos permitem substituir um nó com falha e concluir healing rapidamente, minimizando indisponibilidade. Ajuste comandos e configs ao seu ambiente, garantindo ordem correta de operações. \ No newline at end of file diff --git a/docs/pt/features/ai/images/ai-performance.png b/docs/pt/features/ai/images/ai-performance.png new file mode 100644 index 0000000..f116256 Binary files /dev/null and b/docs/pt/features/ai/images/ai-performance.png differ diff --git a/docs/pt/features/ai/images/cloud-operations.png b/docs/pt/features/ai/images/cloud-operations.png new file mode 100644 index 0000000..2d777c2 Binary files /dev/null and b/docs/pt/features/ai/images/cloud-operations.png differ diff --git a/docs/pt/features/ai/images/data-protection.png b/docs/pt/features/ai/images/data-protection.png new file mode 100644 index 0000000..aa6676e Binary files /dev/null and b/docs/pt/features/ai/images/data-protection.png differ diff --git a/docs/pt/features/ai/images/edge-ai-storage.png b/docs/pt/features/ai/images/edge-ai-storage.png new file mode 100644 index 0000000..6440147 Binary files /dev/null and b/docs/pt/features/ai/images/edge-ai-storage.png differ diff --git a/docs/pt/features/ai/images/fault-tolerant-storage.png b/docs/pt/features/ai/images/fault-tolerant-storage.png new file mode 100644 index 0000000..8408a01 Binary files /dev/null and b/docs/pt/features/ai/images/fault-tolerant-storage.png differ diff --git a/docs/pt/features/ai/images/lifecycle-management.png b/docs/pt/features/ai/images/lifecycle-management.png new file mode 100644 index 0000000..4508100 Binary files /dev/null and b/docs/pt/features/ai/images/lifecycle-management.png differ diff --git a/docs/pt/features/ai/images/llm-storage.png b/docs/pt/features/ai/images/llm-storage.png new file mode 100644 index 0000000..bde8443 Binary files /dev/null and b/docs/pt/features/ai/images/llm-storage.png differ diff --git a/docs/pt/features/ai/images/multi-engine-1.svg b/docs/pt/features/ai/images/multi-engine-1.svg new file mode 100644 index 0000000..a7d3e2d --- /dev/null +++ b/docs/pt/features/ai/images/multi-engine-1.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/pt/features/ai/images/multi-engine-2.svg b/docs/pt/features/ai/images/multi-engine-2.svg new file mode 100644 index 0000000..57f0c9d --- /dev/null +++ b/docs/pt/features/ai/images/multi-engine-2.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/pt/features/ai/images/object-retention.png b/docs/pt/features/ai/images/object-retention.png new file mode 100644 index 0000000..10a5864 Binary files /dev/null and b/docs/pt/features/ai/images/object-retention.png differ diff --git a/docs/pt/features/ai/images/rag-storage.png b/docs/pt/features/ai/images/rag-storage.png new file mode 100644 index 0000000..868e889 Binary files /dev/null and b/docs/pt/features/ai/images/rag-storage.png differ diff --git a/docs/pt/features/ai/images/reliable-storage.png b/docs/pt/features/ai/images/reliable-storage.png new file mode 100644 index 0000000..868e889 Binary files /dev/null and b/docs/pt/features/ai/images/reliable-storage.png differ diff --git a/docs/pt/features/ai/images/training-inference-scale.png b/docs/pt/features/ai/images/training-inference-scale.png new file mode 100644 index 0000000..868e889 Binary files /dev/null and b/docs/pt/features/ai/images/training-inference-scale.png differ diff --git a/docs/pt/features/ai/index.md b/docs/pt/features/ai/index.md new file mode 100644 index 0000000..52fbed5 --- /dev/null +++ b/docs/pt/features/ai/index.md @@ -0,0 +1,57 @@ +# A revolução da IA é impulsionada por GPUs e armazenamento de objetos de alto desempenho + +Somos armazenamento de objetos de alto desempenho. + +## Armazenamento para IA com performance em escala + +![Performance IA](images/ai-performance.png) + +O RustFS usa arquitetura distribuída e armazenamento de objetos. Durante treino, o paralelismo de dados e I/O reduz latência e acelera epochs. Em inferência, o alto throughput garante acesso rápido aos modelos e datasets. A performance escala linearmente de 100 TB a 100 PB+. + +## No centro do ecossistema de IA + +O RustFS é o padrão S3‑compatível para workloads de IA. O ecossistema AI/ML integra‑se nativamente. + +![Ecossistema](images/multi-engine-1.svg) + +![Ecossistema](images/multi-engine-2.svg) + +## Escala para treino e inferência + +Dados corporativos crescem continuamente; LLMs e aplicações usam esses dados para re‑treino. A escalabilidade do RustFS permite crescer capacidade sob demanda, com acesso eficiente. + +## Resiliência para IA + +Armazenamento de objetos tolerante a falhas para datasets, modelos e artefatos. Com replicação e EC, workflows seguem operando mesmo diante de falhas. + +## Always‑On para AI/ML + +Replicação ativo‑ativo permite acesso simultâneo entre clusters distribuídos, aumentando disponibilidade e reduzindo latência para equipas globais. + +## Armazenamento para LLMs + +Integração fluida com LLMs para pré‑treino, fine‑tuning e artefatos. Paralelismo de acesso reduz gargalos e acelera treino/inferência. + +## Contexto para RAG + +Use o RustFS como backend de alto desempenho para RAG: armazene corpora e permita respostas de LLMs específicas ao domínio com baixa latência. + +## Cloud como modelo operacional – começa com S3 + +Contentorização, orquestração, automação, APIs e compatibilidade S3. A compatibilidade garante que frameworks AI/ML funcionem com o RustFS independentemente da cloud. + +## Edge AI + +Binário <100 MB, deploy em qualquer hardware. Bucket Notifications e Object Lambda facilitam pipelines que fazem pre‑processamento para inferência imediata. + +## Gestão do ciclo de vida para AI/ML + +Políticas automatizam movimentação de dados menos acessados para camadas económicas, mantendo foco no treino/desenvolvimento. + +## Retenção de objetos para workflows AI/ML + +WORM e políticas de retenção asseguram integridade, conformidade e reprodutibilidade. + +## Proteção de dados para datasets de IA + +EC, replicação, encriptação em trânsito/repouso, e IAM granular asseguram integridade, disponibilidade e confidencialidade em todo o ciclo de vida. diff --git a/docs/pt/features/aliyun/images/sec1-1.png b/docs/pt/features/aliyun/images/sec1-1.png new file mode 100644 index 0000000..07116ed Binary files /dev/null and b/docs/pt/features/aliyun/images/sec1-1.png differ diff --git a/docs/pt/features/aliyun/index.md b/docs/pt/features/aliyun/index.md new file mode 100644 index 0000000..d8020c6 --- /dev/null +++ b/docs/pt/features/aliyun/index.md @@ -0,0 +1,55 @@ +# RustFS para Alibaba Cloud Container Service for Kubernetes (ACK) + +## Três razões para executar RustFS no Alibaba Cloud + +- Camada de armazenamento consistente em cenários híbridos/multicloud +- Produto cloud‑native de alto desempenho no Kubernetes (público/privado/edge) +- Controle da pilha no ACK, evitando lock‑in + +O ACK é um serviço gerido para executar Kubernetes no Alibaba Cloud sem gerir control plane ou nós. + +O RustFS oferece armazenamento de objetos portátil e performante nas principais plataformas Kubernetes (ACK, Tanzu, Azure, GCP, etc.). No Alibaba Cloud, integra‑se nativamente ao ACK para operar storage multi‑inquilino em escala, como alternativa completa ao S3. + +![Arquitetura RustFS](images/sec1-1.png) + +Diferente do S3, o RustFS permite escalar aplicações entre nuvens sem reescritas dispendiosas ou integrações proprietárias. Por ser contentorizado e cloud‑native, implanta‑se facilmente sem skills especializados em storage massivo. + +## Integração nativa do RustFS Operator com ACK + +### Visão geral + +- Classes de armazenamento e tiering +- Load balancer externo +- Gestão de chaves (KMS) +- Gestão de identidade +- Gestão de certificados +- Monitorização e alertas +- Logging e auditoria + +## Classes de armazenamento e tiering + +Tiering entre classes/mídias (NVMe, HDD, cloud) para equilibrar custo e performance. Namespace único e movimentos transparentes por políticas. + +## Load balancer externo + +Tráfego HTTP/REST com suporte a Ingress compatível com Kubernetes (hardware/software). NGINX é opção popular. + +## Gestão de chaves (KMS) + +Recomenda‑se encriptação por padrão em todos os buckets. Suporte a AES‑256‑GCM/ChaCha20‑Poly1305 com overhead mínimo e modos SSE‑KMS/SSE‑S3/SSE‑C. KMS inicializa KES por tenant para encriptação por objeto. + +## Gestão de identidade + +SSO via OpenID Connect/LDAP (Keycloak, Okta/Auth0, Google, AD, OpenLDAP). RustFS fornece utilizadores/grupos/papéis/políticas/STS ao estilo AWS IAM. + +## Gestão de certificados + +Todo tráfego app↔RustFS e inter‑nós usa TLS. Integração com gestor de certificados para provisionamento/renovação automático por tenant. + +## Monitorização e alertas + +Métricas Prometheus (capacidade, acessos etc.), visualização via Grafana/stack de monitoring; defina baselines e alertas. + +## Logging e auditoria + +A auditoria regista todas as operações de objetos e erros de console; suporte a envio para Elastic Stack/terceiros. diff --git a/docs/pt/features/aws-elastic/images/sec1-1.png b/docs/pt/features/aws-elastic/images/sec1-1.png new file mode 100644 index 0000000..07116ed Binary files /dev/null and b/docs/pt/features/aws-elastic/images/sec1-1.png differ diff --git a/docs/pt/features/aws-elastic/index.md b/docs/pt/features/aws-elastic/index.md new file mode 100644 index 0000000..8fa3626 --- /dev/null +++ b/docs/pt/features/aws-elastic/index.md @@ -0,0 +1,55 @@ +# RustFS para Amazon Elastic Kubernetes Service (EKS) + +## Três razões para executar RustFS no Amazon EKS + +- Camada de armazenamento consistente em cenários híbridos/multicloud +- Produto cloud‑native de alto desempenho no Kubernetes (público/privado/edge) +- Controle total da pilha no EKS, evitando lock‑in + +Amazon Elastic Kubernetes Service (EKS) é um serviço gerido para executar Kubernetes na AWS sem gerir o control plane ou nós. + +O RustFS integra‑se nativamente ao EKS para operar armazenamento de objetos multi‑inquilino em escala, como alternativa compatível com S3. + +![Arquitetura RustFS](images/sec1-1.png) + +Diferente do S3, o RustFS permite escalar aplicações entre nuvens sem reescritas dispendiosas ou integrações proprietárias. Por ser contentorizado e cloud‑native, implanta‑se facilmente sem skills especializados. + +## Integração nativa do RustFS Operator com EKS + +### Visão geral + +- Classes de armazenamento e tiering +- Load balancer externo +- Gestão de chaves (KMS) +- Gestão de identidade +- Gestão de certificados +- Monitorização e alertas +- Logging e auditoria + +## Classes de armazenamento e tiering + +Tiering entre classes/mídias (NVMe, HDD, cloud) com namespace único e políticas transparentes. + +## Load balancer externo + +Suporte a Ingress compatível com Kubernetes (inclui NGINX). Instale via marketplace e exponha tenants. + +## Gestão de chaves (KMS) + +Encriptação por padrão recomendada; suporta AES‑256‑GCM/ChaCha20‑Poly1305 e SSE‑KMS/SSE‑S3/SSE‑C. KMS inicializa KES por tenant. + +## Gestão de identidade + +SSO via OpenID Connect/LDAP (Keycloak, Okta/Auth0, Google, AD, OpenLDAP). IAM estilo AWS. + +## Gestão de certificados + +TLS fim‑a‑fim; integração com gestor de certificados. + +## Monitorização e alertas + +Métricas Prometheus; Grafana/monitoring; alertas. + +## Logging e auditoria + +Auditoria de operações e erros; exportação para Elastic Stack/terceiros. diff --git a/docs/pt/features/baremetal/images/sec2-1.png b/docs/pt/features/baremetal/images/sec2-1.png new file mode 100644 index 0000000..bb3d365 Binary files /dev/null and b/docs/pt/features/baremetal/images/sec2-1.png differ diff --git a/docs/pt/features/baremetal/images/sec2-2.png b/docs/pt/features/baremetal/images/sec2-2.png new file mode 100644 index 0000000..f049ca9 Binary files /dev/null and b/docs/pt/features/baremetal/images/sec2-2.png differ diff --git a/docs/pt/features/baremetal/images/sec2-3.png b/docs/pt/features/baremetal/images/sec2-3.png new file mode 100644 index 0000000..a1903c1 Binary files /dev/null and b/docs/pt/features/baremetal/images/sec2-3.png differ diff --git a/docs/pt/features/baremetal/images/sec2-4.png b/docs/pt/features/baremetal/images/sec2-4.png new file mode 100644 index 0000000..fbbb23f Binary files /dev/null and b/docs/pt/features/baremetal/images/sec2-4.png differ diff --git a/docs/pt/features/baremetal/index.md b/docs/pt/features/baremetal/index.md new file mode 100644 index 0000000..6b0003d --- /dev/null +++ b/docs/pt/features/baremetal/index.md @@ -0,0 +1,61 @@ +# Implementação bare‑metal e virtualizada para Windows/Linux + +Open source, compatível com S3, reforçado para enterprise e extremamente rápido. + +O RustFS é um armazenamento de objetos distribuído de alto desempenho. Definido por software, executa em hardware padrão de mercado e é 100% open source (licença principal: Apache v2.0). + +Diferencial: desenhado desde o início como padrão para armazenamento de objetos de nuvem privada/híbrida. Focado exclusivamente em objetos, a arquitetura single‑tier reúne os recursos necessários sem sacrificar performance – resultando num servidor cloud‑native leve, escalável e rápido. + +Embora brilhe em casos clássicos (backup/DR/arquivamento), o RustFS destaca‑se em desafios de ML/analytics/apps cloud‑native. + +## Características‑chave + +### Erasure Coding + +Proteção por EC inline por objeto (implementação otimizada, inclusive em baixo nível) para máxima performance. Usa Reed‑Solomon para striping em blocos de dados/paridade com redundância configurável. O repair ocorre ao nível do objeto e múltiplos objetos podem ser reparados em paralelo. + +Com paridade até N/2, garante leituras/escritas contínuas com apenas ((N/2)+1) discos operacionais (ex.: em 12 discos, fragmentos 6+6; escreve/reconstrói com 7 discos). + +![Erasure Coding](./images/sec2-1.png) + +### Proteção contra bitrot + +Corrupção silenciosa é um problema sério. O RustFS usa implementação otimizada de HighwayHash para nunca ler dados corrompidos – captura e repara no ato. Calcula hash no READ e valida no WRITE (app→rede→memória/disco) garantindo integridade end‑to‑end. Projetado para velocidade (10+ GB/s por core em CPUs Intel). + +![Proteção bitrot](./images/sec2-2.png) + +### Encriptação no servidor + +Encriptar em trânsito é uma parte; proteger at‑rest é outra. O RustFS suporta esquemas server‑side avançados (AES‑256‑GCM, ChaCha20‑Poly1305, AES‑CBC), com overhead desprezável, além de client‑side. Objetos encriptados usam AEAD, e integra com KMS (ex.: HashiCorp Vault) para SSE‑S3. + +Se SSE‑S3 for requerido ou encriptação automática estiver ativa, cada objeto recebe chave única protegida por master key do KMS. Com baixo overhead, a encriptação automática pode ser padrão por aplicação/instância. + +![Server‑side encryption](./images/sec2-3.png) + +### WORM (Write Once Read Many) + +#### Gestão de identidade + +Integra IdPs compatíveis com OpenID Connect e fornecedores líderes. Acesso centralizado, senhas temporárias/rotativas, políticas de acesso granulares – facilitando multi‑tenant/multi‑instância. + +#### Replicação contínua + +Replicações tradicionais não escalam bem acima de centenas de TiB. É preciso DR entre DCs/regiões. A replicação contínua do RustFS é desenhada para grande escala geodistribuída, usando notificações Lambda e metadados para deltas eficientes e rápidos (propagação imediata, não batch). + +#### Federação global + +Dados em todo lugar. Combine instâncias distintas num namespace global unificado: múltiplos servidores RustFS em “conjuntos distribuídos”, e vários conjuntos formando uma federação. Oferece administração e namespace unificados. + +#### Gateway multicloud + +Estratégia multicloud (pública e privada) exige que a infraestrutura pareça S3. O RustFS corre em bare‑metal, NAS e nuvens; e pode tornar a infraestrutura existente compatível com S3, unificando dados (file/block→object via S3 API) sem migração. + +![WORM](./images/sec2-4.png) + +## Arquitetura do sistema + +Cloud‑native, executa como contentor leve gerido por orquestrador (ex.: Kubernetes). O servidor é um binário estático (~40 MB), eficiente em CPU/memória mesmo sob carga, permitindo alta densidade multi‑tenant em hardware partilhado. + +Executa em servidores COTS com discos locais (JBOD/JBOF). Todos os nós são simétricos (sem NameNode/servidor de metadados). Dados e metadados são escritos juntos como objetos (sem BD de metadados). EC/bitrot/encriptação são inline e estritamente consistentes, para elevada resiliência. + +Cada cluster é um conjunto de processos de servidor (um por nó), user‑space single‑process com corrotinas leves para alta concorrência. Discos agrupados em conjuntos de EC (padrão 16 discos) e colocação por hashing determinístico. Desenhado para multi‑DC em grande escala; cada tenant opera seu próprio cluster, isolado e federado geograficamente. diff --git a/docs/pt/features/cloud-native/images/multi-cloud-architecture.png b/docs/pt/features/cloud-native/images/multi-cloud-architecture.png new file mode 100644 index 0000000..4833d67 Binary files /dev/null and b/docs/pt/features/cloud-native/images/multi-cloud-architecture.png differ diff --git a/docs/pt/features/cloud-native/index.md b/docs/pt/features/cloud-native/index.md new file mode 100644 index 0000000..1f83d6b --- /dev/null +++ b/docs/pt/features/cloud-native/index.md @@ -0,0 +1,53 @@ +# Armazenamento de objetos híbrido/multicloud + +Arquiteturas híbridas/multicloud alcançam consistência em performance, segurança e economia. “Multicloud” não é apenas um único provedor público + on‑prem. + +## Estratégias vencedoras usam arquiteturas e ferramentas que executam em qualquer ambiente + +### Nuvem pública + +De AWS, Azure, GCP, IBM a Alibaba, Tencent e clouds governamentais. O seu storage precisa executar onde a pilha da aplicação está. Mesmo quem diz operar num único cloud invariavelmente usa outros. O RustFS oferece consistência entre provedores, evitando reescrita ao expandir para novas nuvens. + +### Nuvem privada + +Kubernetes é a base das nuvens privadas modernas (Tanzu, OpenShift, Rancher/SUSE, HP Ezmeral, Rafay). Multicloud K8s requer armazenamento de objetos cloud‑native e definido por software. Inclui bare‑metal tradicional, mas workloads empresariais migram para contentores e orquestração. + +### Edge + +Edge move computação para onde os dados são gerados, depois envia para centros. Soluções de edge storage devem ser leves, potentes, cloud‑native e resilientes para operar em multicloud – tarefa difícil, raramente resolvida até por grandes provedores. + +## Arquitetura multicloud com RustFS + +![Arquitetura multicloud](images/multi-cloud-architecture.png) + +## Atributos de storage híbrido/multicloud + +O padrão dominante em nuvem pública é o armazenamento de objetos cloud‑native. O sucesso dos clouds tornou file/block legados obsoletos. Novas apps usam S3 API, não POSIX. Apps legadas devem ser reescritas para S3 e refatoradas em microserviços para contentores. + +### Kubernetes‑Native + +Operadores gerem tenants multi‑inquilino via CRDs, com orquestração, upgrades sem downtime e scale‑out, mantendo alta disponibilidade. O RustFS tira partido do desenho K8s. Binários leves permitem alta densidade de co‑alojamento de tenants com Operator. + +### Consistência + +Consistência de API, performance, segurança e conformidade, independente do hardware. Alterações mínimas podem quebrar apps e elevar o ônus operacional. + +Leveza do RustFS permite updates sem interrupção em minutos em público/privado/edge, abstraindo diferenças (KMS/Identidade/políticas/OS/hardware). + +### Performance + +Object storage é storage primário e secundário: precisa escalar performance. De mobile/web a AI/ML, workloads intensivos dependem de performance. Backups exigem dedupe/snapshot rápidos; ninguém tolera recuperação lenta. Antes exigiam bare‑metal; hoje podem ser contentorizados. + +RustFS entrega topo de performance (ex.: NVMe leitura/escrita 325/171 GiB/s; HDD 11/9 GiB/s), viabilizando qualquer workload em qualquer infra, em qualquer multicloud. + +### Escalável + +Escala não é só “o quão grande”. Eficiência operacional é central. A solução deve escalar com automação máxima e intervenção mínima, via plataforma API‑driven sobre arquitetura simples. + +O foco em simplicidade do RustFS permite gerir infra de múltiplos PB com equipa enxuta – produto de APIs/automação que sustentam storage multicloud escalável. + +### Definido por software + +Sucesso em multicloud exige SDS. Appliances não executam em clouds/K8s. Ofertas de storage de clouds não foram feitas para correr noutros clouds, privados ou K8s; e o custo de bandwidth supera o de storage. SDS corre em público/privado/edge. + +RustFS nasce em software e é portátil em OS/arquiteturas, comprovado pelas 2M+ IPs a correr em AWS, GCP e Azure. diff --git a/docs/pt/features/cold-archiving/index.md b/docs/pt/features/cold-archiving/index.md new file mode 100644 index 0000000..695bb95 --- /dev/null +++ b/docs/pt/features/cold-archiving/index.md @@ -0,0 +1,101 @@ +# Solução de arquivamento frio em armazenamento de objetos + +Base sustentável, segura e inteligente para dados de longo prazo. + +## Desafios principais + +### Retenção de longo prazo + +- Longevidade de mídias (fita 10–30 anos) +- Formatos legados vs. sistemas modernos +- Custo/complexidade de auditoria e conformidade + +### Continuidade com conectividade limitada + +- Risco físico em bibliotecas de fita +- Latência elevada em replicação geográfica +- Tempos longos de disponibilização de dados frios + +### Segurança de dados offline + +- Mitigar malware/ransomware em dados arquivados +- Custos de implementar air‑gap +- Risco de erros de decodificação/índices de metadados + +## Abordagem + +### Motor de storage em camadas + +#### Tiering inteligente + +Classificação automática por frequência de acesso (quente→morno→frio→deep‑cold) e migração para mídias de menor custo (HDD/fita/óptico) conforme políticas. + +#### Interoperabilidade + +Compatível com S3, NAS, HDFS e implantações cloud/privadas. + +### Gestão de dados de longo prazo + +#### Abstração independente de mídia + +Camada lógica de volumes para abstrair diferenças de hardware e permitir evolução de fita→QLC e além. + +#### Auto‑healing e verificação periódica + +Verificação cíclica (CRC/EC) com correção automática de erros silenciosos. + +### Segurança e confiança + +#### Air Gap + +Isolamento físico/mediado para reduzir superfície de ataque. + +#### Prova de integridade + +Registo imutável de metadados/ações para auditoria. + +### Eficiência energética + +#### Baixo consumo em repouso + +Mídias e políticas orientadas a reduzir consumo quando inativas. + +#### Orquestração por políticas + +Previsão de acessos para otimizar picos de energia. + +## Casos de uso + +### Arquivos históricos + +- Digitalização e preservação documental +- Redução de OPEX de operação + +### Dados científicos + +- Pesquisa/engenharia com volumes em PB +- Codificação/EC para densidade e resiliência + +### Media/Entretenimento + +- Arquivo de masters 4K/8K +- Indexação/pesquisa eficiente + +## Comparativo + +| Dimensão | Abordagem tradicional | Com RustFS | Benefício | +|---------|------------------------|------------|-----------| +| Longevidade | Depende de migrações periódicas | Abstração de mídia + redundância lógica | Menos migrações, menor risco de obsolescência | +| Energia | Bibliotecas ativas consomem continuamente | Políticas de repouso e camadas frias | TCO reduzido | +| RTO | Demora de rehidratação | Leitura direta de dados frios (conforme política) | Recuperação mais rápida | +| Conformidade | Auditoria manual | Relato automatizado + trilha de auditoria | Facilita certificações | + +## Setores + +- Finanças: retenção/regulatório +- HPC: cold standby de datasets +- Mídia: arquivo de conteúdos em alta resolução + +## Contacto + +Fale connosco para avaliar requisitos de arquivamento a longo prazo com RustFS. diff --git a/docs/pt/features/commvault/images/atomic-metadata.png b/docs/pt/features/commvault/images/atomic-metadata.png new file mode 100644 index 0000000..136cdc4 Binary files /dev/null and b/docs/pt/features/commvault/images/atomic-metadata.png differ diff --git a/docs/pt/features/commvault/images/commvault-logo.png b/docs/pt/features/commvault/images/commvault-logo.png new file mode 100644 index 0000000..feadea7 Binary files /dev/null and b/docs/pt/features/commvault/images/commvault-logo.png differ diff --git a/docs/pt/features/commvault/images/fast-performance.png b/docs/pt/features/commvault/images/fast-performance.png new file mode 100644 index 0000000..ebab4db Binary files /dev/null and b/docs/pt/features/commvault/images/fast-performance.png differ diff --git a/docs/pt/features/commvault/images/scalability.png b/docs/pt/features/commvault/images/scalability.png new file mode 100644 index 0000000..baf077e Binary files /dev/null and b/docs/pt/features/commvault/images/scalability.png differ diff --git a/docs/pt/features/commvault/images/simple-secure.png b/docs/pt/features/commvault/images/simple-secure.png new file mode 100644 index 0000000..6e61219 Binary files /dev/null and b/docs/pt/features/commvault/images/simple-secure.png differ diff --git a/docs/pt/features/commvault/index.md b/docs/pt/features/commvault/index.md new file mode 100644 index 0000000..03c1b91 --- /dev/null +++ b/docs/pt/features/commvault/index.md @@ -0,0 +1,51 @@ +# Object storage de alto desempenho para Commvault (backup, restore e replicação) + +**Simples. Escalável. Rápido. Resistente a ransomware. Exatamente o que precisa.** + +## Vantagens + +### 🔒 Simples = Seguro + +Commvault e RustFS simplificam backup e restore para proteger os seus dados – de VMs ao Microsoft 365. + +### 📈 Escala simples + +O RustFS escala linearmente com clusters de servidores, até EB e além. O Commvault foca no core, enquanto o RustFS cuida de heterogeneidade de hardware, erasure coding e proteção contra bitrot. Assim, é possível expandir o backup e proteger mais dados. + +### ⚡ Backup rápido é uma coisa; restore rápido é outra + +RustFS + Commvault pode exceder 325 GiB/s de leitura/escrita num cluster de 32 nós, permitindo backup/restore a velocidades antes impraticáveis. + +### ⚛️ Atómico + +O RustFS grava metadados de forma atômica com os objetos, dispensando bases externas (como Cassandra) em muitos casos. Elimina penalidades comuns de pequenos objetos e atende às recomendações de tamanho do Commvault. + +### 🔐 Inline e consistente + +Todo I/O é commitado com EC/bitrot/encriptação inline. O serviço S3 é resiliente a interrupções/reinícios. Sem staging assíncrono: garantia de operações concluídas. + +### 🔧 Agnóstico a hardware + +Definido por software e agnóstico a hardware, o RustFS dá flexibilidade e economia no design de soluções de backup com Commvault. + +## Visão geral da solução + +RustFS e Commvault oferecem soluções de backup definidas por software. O armazenamento de objetos de alto desempenho do RustFS atua como endpoint, desacoplando computação e armazenamento, com performance, escala e economia. Um único cluster pode servir endpoints para VMs, Oracle, SAP e MS Office. + +## Principais cenários + +### 🖥️ Backups Commvault para VMware ESXi com RustFS + +Backups de infraestrutura virtual para armazenamento de objetos com elasticidade e controlo de custo/segurança. + +### 📧 Backups Commvault para Microsoft 365 com RustFS + +Backups do Microsoft 365 para armazenamento de objetos com gestão eficiente. + +### 💼 Backups Commvault para SAP HANA com RustFS + +Desempenho e segurança reforçados. + +### 🗄️ Backups Commvault para Oracle com RustFS + +Otimização de backups críticos de Oracle usando armazenamento de objetos RustFS. diff --git a/docs/pt/features/data-lake/images/data-lake-architecture.png b/docs/pt/features/data-lake/images/data-lake-architecture.png new file mode 100644 index 0000000..ef36c5a Binary files /dev/null and b/docs/pt/features/data-lake/images/data-lake-architecture.png differ diff --git a/docs/pt/features/data-lake/images/decomposition.png b/docs/pt/features/data-lake/images/decomposition.png new file mode 100644 index 0000000..5e03c7a Binary files /dev/null and b/docs/pt/features/data-lake/images/decomposition.png differ diff --git a/docs/pt/features/data-lake/images/elt-etl.png b/docs/pt/features/data-lake/images/elt-etl.png new file mode 100644 index 0000000..9de50df Binary files /dev/null and b/docs/pt/features/data-lake/images/elt-etl.png differ diff --git a/docs/pt/features/data-lake/images/lightweight.png b/docs/pt/features/data-lake/images/lightweight.png new file mode 100644 index 0000000..10a5864 Binary files /dev/null and b/docs/pt/features/data-lake/images/lightweight.png differ diff --git a/docs/pt/features/data-lake/images/multi-engine-1.svg b/docs/pt/features/data-lake/images/multi-engine-1.svg new file mode 100644 index 0000000..a7d3e2d --- /dev/null +++ b/docs/pt/features/data-lake/images/multi-engine-1.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/pt/features/data-lake/images/multi-engine-2.svg b/docs/pt/features/data-lake/images/multi-engine-2.svg new file mode 100644 index 0000000..57f0c9d --- /dev/null +++ b/docs/pt/features/data-lake/images/multi-engine-2.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/pt/features/data-lake/images/open-source.png b/docs/pt/features/data-lake/images/open-source.png new file mode 100644 index 0000000..5e03c7a Binary files /dev/null and b/docs/pt/features/data-lake/images/open-source.png differ diff --git a/docs/pt/features/data-lake/images/performance.png b/docs/pt/features/data-lake/images/performance.png new file mode 100644 index 0000000..2d777c2 Binary files /dev/null and b/docs/pt/features/data-lake/images/performance.png differ diff --git a/docs/pt/features/data-lake/images/rapid-growth.png b/docs/pt/features/data-lake/images/rapid-growth.png new file mode 100644 index 0000000..67659da Binary files /dev/null and b/docs/pt/features/data-lake/images/rapid-growth.png differ diff --git a/docs/pt/features/data-lake/images/resilience.png b/docs/pt/features/data-lake/images/resilience.png new file mode 100644 index 0000000..9d9c67b Binary files /dev/null and b/docs/pt/features/data-lake/images/resilience.png differ diff --git a/docs/pt/features/data-lake/images/security.png b/docs/pt/features/data-lake/images/security.png new file mode 100644 index 0000000..f60e708 Binary files /dev/null and b/docs/pt/features/data-lake/images/security.png differ diff --git a/docs/pt/features/data-lake/images/simplicity.png b/docs/pt/features/data-lake/images/simplicity.png new file mode 100644 index 0000000..d8a9ef1 Binary files /dev/null and b/docs/pt/features/data-lake/images/simplicity.png differ diff --git a/docs/pt/features/data-lake/images/software-defined.png b/docs/pt/features/data-lake/images/software-defined.png new file mode 100644 index 0000000..d2e4019 Binary files /dev/null and b/docs/pt/features/data-lake/images/software-defined.png differ diff --git a/docs/pt/features/data-lake/images/table-formats.png b/docs/pt/features/data-lake/images/table-formats.png new file mode 100644 index 0000000..ec12655 Binary files /dev/null and b/docs/pt/features/data-lake/images/table-formats.png differ diff --git a/docs/pt/features/data-lake/index.md b/docs/pt/features/data-lake/index.md new file mode 100644 index 0000000..e47e4ca --- /dev/null +++ b/docs/pt/features/data-lake/index.md @@ -0,0 +1,51 @@ +# RustFS para data lakes modernos + +Data lakes e lakehouses modernos assentam em armazenamento de objetos moderno – isto é, sobre RustFS. + +**RustFS fornece armazenamento unificado para data lakes/lakehouses modernos, executando em qualquer ambiente: privado, público, colocation, bare‑metal e edge – rápido, escalável, cloud‑native e pronto para uso.** + +![Arquitetura do data lake](images/data-lake-architecture.png) + +## Pronto para formatos de tabela abertos + +![Formatos de tabela](images/table-formats.png) + +Data lakes modernos são multi‑engine (Spark, Flink, Trino, Arrow, Dask, etc.) e requerem armazenamento de tabelas central, portabilidade, controlo de acesso e estruturas persistentes. Formatos como Iceberg, Hudi e Delta Lake atendem a essas necessidades e são suportados pelo RustFS. + +## Cloud‑native + +Nascido na cloud e aderente a contentores, orquestração, microserviços, APIs, IaC e automação. Ecossistemas cloud‑native “funcionam juntos” com o RustFS: de Spark a Trino, de Snowflake a Dremio, de NiFi a Kafka, de Prometheus a OpenObserve, de Istio a Linkerd, de HashiCorp Vault a Keycloak. + +## Multi‑engine + +Compatível com todos os motores que falam S3. Se faltar algum, fale connosco. + +![Multi‑engine](images/multi-engine-1.svg) + +![Multi‑engine](images/multi-engine-2.svg) + +## Performance + +Data lakes exigem performance maciça e consistente. O RustFS supera arquiteturas legadas e tem caminhos de migração claros. Isso beneficia motores de consulta (Spark, Presto/Trino, Snowflake, SQL Server, Teradata, etc.) e plataformas AI/ML (MLflow, Kubeflow). + +Publicamos benchmarks reproduzíveis. + +## Leve + +Binário de servidor <100 MB. Potente no data center, pequeno o suficiente para o edge. Aplicações S3 usam as mesmas APIs em qualquer lugar. Com replicação, capturamos/filtramos dados no edge e enviamos ao cluster central para agregação e análise. + +## Desacoplado + +Processamento de consulta e storage desacoplados: motores focam em otimização de query e o RustFS em throughput. Com subsets em memória, S3 Select/predicate pushdown e tabelas externas, os motores ganham flexibilidade. + +## Open source + +Empresas que adotaram Hadoop valorizam open source. Como sucessor lógico, esperam data lakes abertos. O RustFS é 100% open source, oferecendo verificabilidade e sem lock‑in. + +## Ingestão contínua + +Dados são gerados continuamente. RustFS integra‑se com Kafka, Flink, RabbitMQ e mais, para que o lake/lakehouse seja a fonte única de verdade e escale até EB. + +## Simples + +Simplicidade exige disciplina e compromisso. Nosso objetivo é tornar o RustFS fácil de instalar, usar, atualizar e escalar, reduzindo as partes móveis para acelerar a adoção. diff --git a/docs/pt/features/distributed/images/s2-1.png b/docs/pt/features/distributed/images/s2-1.png new file mode 100644 index 0000000..be0d98e Binary files /dev/null and b/docs/pt/features/distributed/images/s2-1.png differ diff --git a/docs/pt/features/distributed/index.md b/docs/pt/features/distributed/index.md new file mode 100644 index 0000000..0fc61e8 --- /dev/null +++ b/docs/pt/features/distributed/index.md @@ -0,0 +1,20 @@ +--- +title: "Infraestrutura para dados em grande escala" +description: "RustFS desenhado para escalar: técnico, operacional e económico" +--- + +# Infraestrutura para dados em grande escala + +O RustFS foi desenhado para escalar: a nível técnico, operacional e económico. + +É cloud‑native e pode ser executado como um contentor leve orquestrado por Kubernetes. O servidor tem ~100 MB como binário estático e é eficiente em CPU e memória mesmo sob carga, permitindo consolidar muitos tenants no mesmo hardware. + +![Arquitetura do RustFS](./images/s2-1.png) + +O RustFS corre em qualquer lugar e em qualquer cloud, tipicamente em servidores COTS com JBOD/JBOF. Todos os servidores do cluster são funcionalmente equivalentes (arquitetura totalmente simétrica). Não há name node nem servidor de meta‑dados. + +O RustFS escreve dados e meta‑dados juntos como objetos, dispensando base de meta‑dados. Funcionalidades como erasure coding, verificação de bit‑rot e encriptação são feitas inline com consistência estrita, garantindo elevada resiliência. + +Cada cluster é um conjunto de servidores RustFS distribuídos, um processo por nó. Corre em espaço de utilizador como processo único com corrotinas leves para alta concorrência. Os discos são agrupados em conjuntos de erasure (ver calculadora de stripes) e os objetos são colocados nesses conjuntos por hashing determinístico. + +O RustFS é desenhado para serviços de armazenamento multi‑datacenter em grande escala. Cada tenant executa o seu próprio cluster RustFS, isolado dos outros, protegendo‑o de impactos de upgrades/segurança; cada um escala de forma independente através de federação geográfica. diff --git a/docs/pt/features/domestic/images/arrow.png b/docs/pt/features/domestic/images/arrow.png new file mode 100644 index 0000000..2d7dda3 Binary files /dev/null and b/docs/pt/features/domestic/images/arrow.png differ diff --git a/docs/pt/features/domestic/images/icon-1.png b/docs/pt/features/domestic/images/icon-1.png new file mode 100644 index 0000000..89d3579 Binary files /dev/null and b/docs/pt/features/domestic/images/icon-1.png differ diff --git a/docs/pt/features/domestic/images/icon-2.png b/docs/pt/features/domestic/images/icon-2.png new file mode 100644 index 0000000..a9deb1e Binary files /dev/null and b/docs/pt/features/domestic/images/icon-2.png differ diff --git a/docs/pt/features/domestic/images/icon-3.png b/docs/pt/features/domestic/images/icon-3.png new file mode 100644 index 0000000..79efca0 Binary files /dev/null and b/docs/pt/features/domestic/images/icon-3.png differ diff --git a/docs/pt/features/domestic/images/icon-4.png b/docs/pt/features/domestic/images/icon-4.png new file mode 100644 index 0000000..3463dd0 Binary files /dev/null and b/docs/pt/features/domestic/images/icon-4.png differ diff --git a/docs/pt/features/domestic/images/item-1.png b/docs/pt/features/domestic/images/item-1.png new file mode 100644 index 0000000..74b2d78 Binary files /dev/null and b/docs/pt/features/domestic/images/item-1.png differ diff --git a/docs/pt/features/domestic/images/item-2.png b/docs/pt/features/domestic/images/item-2.png new file mode 100644 index 0000000..55d996b Binary files /dev/null and b/docs/pt/features/domestic/images/item-2.png differ diff --git a/docs/pt/features/domestic/images/item-3.png b/docs/pt/features/domestic/images/item-3.png new file mode 100644 index 0000000..b9daf84 Binary files /dev/null and b/docs/pt/features/domestic/images/item-3.png differ diff --git a/docs/pt/features/domestic/index.md b/docs/pt/features/domestic/index.md new file mode 100644 index 0000000..0a76028 --- /dev/null +++ b/docs/pt/features/domestic/index.md @@ -0,0 +1,85 @@ +# Solução para ecossistema doméstico (Xinchuang) + +Portfólio completo de conformidade de storage: do hardware e sistemas operativos a requisitos de segurança e encriptação. + +## Dores de implantação + +### Limitações de abordagens tradicionais + +- Baixa taxa de compatibilidade com CPUs domésticas +- Queda de performance em ambientes de conformidade +- Expansão cara em arquiteturas centralizadas + +### Abordagem técnica + +- Adaptação validada para múltiplas arquiteturas de CPU domésticas +- Protocolo de aceleração RDMA para IOPS e latência reduzida +- Metadados distribuídos; escala de cluster até níveis de EB + +## Por que escolher + +### Adaptação full‑stack + +- Suporte a várias plataformas de CPU +- Baixa perda de performance de hardware +- Compatibilidade validada por certificação industrial + +### Garantia de performance + +- Aceleração RDMA proprietária +- Alto IOPS por nó com latências muito baixas + +### Segurança de nível nacional + +- Suporte a suites criptográficas domésticas (SM2/SM4/SM9) +- Alto throughput de encriptação + +### Ecossistema compatível + +- Suporte a múltiplos SOs do ecossistema doméstico +- Integrações com ISVs e validações setoriais + +## Soluções + +### Motor de substituição para órgãos públicos + +- Cobertura de fluxo completo de documentos/reuniões/supervisão +- Mecanismos de confiança cruzada entre sistemas heterogéneos + +### Core distribuído para finanças + +- Motor distribuído de alta TPS +- Pipelines inteligentes de processamento em lote + +### Plataforma unificada para grandes empresas + +- Orquestração heterogénea (x86/ARM/MIPS) +- Ferramentas de migração com mínima intervenção + +## Tabela de funcionalidades + +| Dimensão | Storage tradicional | Solução RustFS | Benefício | +|---------|---------------------|----------------|-----------| +| Protocolos | FC/iSCSI | NVMe‑oF/S3/NFSv4 | Compatibilidade ampla | +| Proteção | Controladoras + RAID | 3 cópias entre DC + EC | RTO reduzido | +| Performance | IOPS por nó limitado | IOPS elevado e alto throughput | Ganho significativo | + +## Serviços + +### Validação de adaptação + +- 5–7 dias úteis +- Relatório de compatibilidade de hardware +- Plano de tuning de performance + +### Implementação + +- 3 dias por PB +- Arquitetura ativo‑ativo +- Migração sem perda + +### Operação contínua + +- Monitorização 24x7 +- Health check anual +- SLA de alta disponibilidade diff --git a/docs/pt/features/encryption/images/s5-1.png b/docs/pt/features/encryption/images/s5-1.png new file mode 100644 index 0000000..21170ef Binary files /dev/null and b/docs/pt/features/encryption/images/s5-1.png differ diff --git a/docs/pt/features/encryption/images/s5-2.png b/docs/pt/features/encryption/images/s5-2.png new file mode 100644 index 0000000..447c126 Binary files /dev/null and b/docs/pt/features/encryption/images/s5-2.png differ diff --git a/docs/pt/features/encryption/images/s5i-1.png b/docs/pt/features/encryption/images/s5i-1.png new file mode 100644 index 0000000..db2ea30 Binary files /dev/null and b/docs/pt/features/encryption/images/s5i-1.png differ diff --git a/docs/pt/features/encryption/images/s5i-2.png b/docs/pt/features/encryption/images/s5i-2.png new file mode 100644 index 0000000..6190575 Binary files /dev/null and b/docs/pt/features/encryption/images/s5i-2.png differ diff --git a/docs/pt/features/encryption/images/s5i-3.png b/docs/pt/features/encryption/images/s5i-3.png new file mode 100644 index 0000000..f5782f1 Binary files /dev/null and b/docs/pt/features/encryption/images/s5i-3.png differ diff --git a/docs/pt/features/encryption/images/s5i-4.png b/docs/pt/features/encryption/images/s5i-4.png new file mode 100644 index 0000000..0959a23 Binary files /dev/null and b/docs/pt/features/encryption/images/s5i-4.png differ diff --git a/docs/pt/features/encryption/images/s5i-5.png b/docs/pt/features/encryption/images/s5i-5.png new file mode 100644 index 0000000..ddc1357 Binary files /dev/null and b/docs/pt/features/encryption/images/s5i-5.png differ diff --git a/docs/pt/features/encryption/images/s5i-6.png b/docs/pt/features/encryption/images/s5i-6.png new file mode 100644 index 0000000..db50277 Binary files /dev/null and b/docs/pt/features/encryption/images/s5i-6.png differ diff --git a/docs/pt/features/encryption/index.md b/docs/pt/features/encryption/index.md new file mode 100644 index 0000000..f6da659 --- /dev/null +++ b/docs/pt/features/encryption/index.md @@ -0,0 +1,39 @@ +# Infraestrutura para dados em grande escala + +O RustFS é concebido para escalar: técnica, operacional e economicamente. + +Em armazenamento de objetos, a encriptação forte é requisito básico. O RustFS oferece encriptação de alto nível com otimizações amplas, praticamente eliminando overheads típicos da encriptação em storage. + +![Arquitetura de encriptação](images/s5-1.png) + +O RustFS encripta dados em repouso (disco) e em trânsito (rede). O esquema suporta encriptação ao nível do objeto com padrões modernos (AES‑256‑GCM, ChaCha20‑Poly1305, AES‑CBC). É compatível com semântica S3 e estende‑a com KMS não‑AWS (HashiCorp Vault, Thales/Gemalto KeySecure, Google Secrets Manager). + +## Encriptação em rede + +Ao transitar entre aplicações e storage, os dados podem cruzar redes não confiáveis. Encriptar “on‑the‑wire” mitiga ataques MITM e garante confidencialidade independentemente do caminho. + +O RustFS suporta TLS v1.2+ entre todos os componentes do cluster, sem pontos fracos entre nós. A implementação TLS é otimizada ao nível de instruções de CPU, com overhead desprezável. Basta fornecer a cada servidor RustFS a chave privada e o certificado públicos. Em Kubernetes, o Operator trata da emissão/distribuição de certificados (SNI e múltiplos certificados/domínios suportados). + +## Encriptação de objetos (at‑rest) + +Antes de persistir, o servidor encripta automaticamente os dados (at‑rest), garantindo confidencialidade, integridade e autenticidade. Suporta encriptação dirigida pelo cliente e configuração por padrão do bucket. + +Compatível com SSE‑S3 e SSE‑C. Além do AWS KMS, o RustFS integra KMS corporativos (HashiCorp Vault, Thales Ciphertrust). No SSE‑S3 e SSE‑C o servidor executa rotação de chaves e re‑encriptação. + +Com encriptação automática no servidor, cada objeto recebe uma chave única, e camadas adicionais podem ser aplicadas com chaves dinâmicas derivadas de KMS externo ou fornecidas pelo cliente. + +Usa AEAD (AES‑256‑GCM, ChaCha20‑Poly1305) em operações de PUT/GET. Otimizações de CPU (SIMD) tornam o overhead mínimo; pode manter encriptação por bucket ativa sem penalizações relevantes. + +## Serviço de Encriptação de Chaves (KES) + +O KES é um serviço distribuído e sem estado, de alto desempenho, para gestão de chaves, pensado para Kubernetes. É componente requerido para SSE‑S3. + +O KES intermedeia cluster RustFS e KMS externo, gerando chaves e operações de encriptação sem sobrecarregar o KMS central. Sendo stateless, escala automaticamente (HPA). O Operator suporta implantar/configurar KES por inquilino. + +![Arquitetura KES](images/s5-2.png) + +## KMS externos suportados + +| ![AWS KMS](images/s5i-1.png) | ![HashiCorp Vault](images/s5i-2.png) | ![Google Secret Manager](images/s5i-3.png) | +|-------------------------------|----------------------------------------|-------------------------------------------| +| ![Azure Key Vault](images/s5i-4.png) | ![Thales CipherTrust](images/s5i-5.png) | ![Fortanix](images/s5i-6.png) | diff --git a/docs/pt/features/hdfs/index.md b/docs/pt/features/hdfs/index.md new file mode 100644 index 0000000..e7328bd --- /dev/null +++ b/docs/pt/features/hdfs/index.md @@ -0,0 +1,132 @@ +# Alternativa ao Hadoop HDFS + +## Desafios do HDFS + +O HDFS teve papel importante, mas com o crescimento exponencial de dados e novas exigências, surgem desafios: + +### Operação complexa + +- Risco de SPOF do NameNode (mesmo com HA) +- Gestão de cluster complexa e dependente de equipa especializada +- Configuração/tuning com curva acentuada + +### Gargalos de performance + +- Pequenos ficheiros consomem memória do NameNode +- Metadados limitam expansão +- Overhead de rede devido a replicação + +### Custos + +- Elevado CAPEX (servidores/storage) +- OPEX e equipa especializada +- Energia/arrefecimento + +## Vantagens do RustFS + +### Arquitetura + +- Descentralizado, sem SPOF +- Cloud‑native, contentorizado e escalável +- Multi‑protocolo: HDFS, S3, NFS + +### Performance + +- Alta concorrência (Rust, segurança de memória) +- Cache multi‑nível +- Layout otimizado, menos tráfego + +### Operação + +- Deploy simplificado e automação +- Monitorização e alertas em tempo real +- Scale‑out elástico + +## Comparativo + +| Característica | HDFS | RustFS | +|------|------|---------| +| Arquitetura | Master/Slave (NameNode/DataNode) | P2P descentralizada | +| SPOF | NameNode | Não | +| Escalabilidade | Limitada à memória do NameNode | Linear | +| Protocolos | HDFS | HDFS, S3, NFS | +| Pequenos ficheiros | Fraco | Otimizado | +| Complexidade de deploy | Alta | Baixa | +| O&M | Equipa especializada | Automatizada | +| Cloud‑native | Limitado | Nativo | + +## Estratégias de migração + +### Offline (DistCP) + +- Janela em baixo tráfego +- Migração por lotes +- Validação de integridade + +### Online (dual‑write) + +- Escrita simultânea para HDFS e RustFS +- Cutover gradual de leituras +- Sincronização contínua + +### Híbrido + +- Camada de acesso unificada +- Roteamento inteligente por características de dados +- Migração progressiva (novo→RustFS, legado→HDFS) + +## Arquitetura moderna + +### Compatibilidade S3 + +- Operações padrão (PUT/GET/DELETE/LIST) +- Multipart upload +- URLs pré‑assinadas +- Versionamento + +### Segurança + +- Criptografia end‑to‑end (em trânsito e at‑rest) +- RBAC granular +- Auditoria completa +- Conformidade + +### Auto‑scale + +- Adaptação dinâmica de nós +- Balanceamento inteligente +- Otimização de recursos +- Redução de TCO + +### Observabilidade + +- Monitorização em tempo real +- Alertas inteligentes +- Análise de performance +- Operação automatizada + +## Análise de custos (TCO) + +| Item | HDFS | RustFS | Poupança | +|------|------|--------|----------| +| Hardware | Alto | Médio | 30–40% | +| Operação | Alto | Baixo | 50–60% | +| Equipa | Alto | Baixo | 40–50% | +| Energia | Alto | Médio | 20–30% | +| TCO | Base | | 40–50% | + +### ROI + +- Deploy de semanas para horas +- O&M reduzido em ~60% +- 2–3× performance +- 40–50% TCO + +### Valor da migração + +- Reduz dívida técnica +- Suporta estratégia cloud‑native +- Otimiza custos +- Acelera inovação (AI/Big Data) + +Ao adotar o RustFS como sucessor do HDFS, resolve‑se os desafios atuais e prepara‑se a transformação digital futura. diff --git a/docs/pt/features/huaweicloud/images/sec1-1.png b/docs/pt/features/huaweicloud/images/sec1-1.png new file mode 100644 index 0000000..07116ed Binary files /dev/null and b/docs/pt/features/huaweicloud/images/sec1-1.png differ diff --git a/docs/pt/features/huaweicloud/index.md b/docs/pt/features/huaweicloud/index.md new file mode 100644 index 0000000..af6651b --- /dev/null +++ b/docs/pt/features/huaweicloud/index.md @@ -0,0 +1,55 @@ +# RustFS para Huawei Cloud CCE Kubernetes Service + +## Três razões para executar RustFS na Huawei Cloud + +- Camada de armazenamento consistente em cenários híbridos/multicloud +- Produto cloud‑native de alto desempenho no Kubernetes (público/privado/edge) +- Controle da pilha no CCE, evitando lock‑in + +O CCE é um serviço gerido para executar Kubernetes na Huawei Cloud sem gerir control plane ou nós. + +O RustFS oferece armazenamento de objetos portátil e performante nas principais plataformas Kubernetes (ACK, Tanzu, Azure, GCP, CCE). No CCE, integra‑se nativamente para operar storage multi‑inquilino em escala, como alternativa ao S3. + +![Arquitetura RustFS](images/sec1-1.png) + +Diferente do S3, o RustFS permite escalar aplicações entre nuvens sem reescritas dispendiosas. Cloud‑native e contentorizado, implanta‑se facilmente. + +## Integração nativa do RustFS Operator com CCE + +### Visão geral + +- Classes de armazenamento e tiering +- Load balancer externo +- Gestão de chaves (KMS) +- Gestão de identidade +- Gestão de certificados +- Monitorização e alertas +- Logging e auditoria + +## Classes de armazenamento e tiering + +Tiering entre NVMe/HDD/cloud com namespace único e políticas. + +## Load balancer externo + +Ingress compatível com Kubernetes (ex.: NGINX). Exponha tenants com anotações. + +## Gestão de chaves (KMS) + +Encriptação por padrão; AES‑256‑GCM/ChaCha20‑Poly1305; SSE‑KMS/SSE‑S3/SSE‑C; KMS inicializa KES por tenant. + +## Gestão de identidade + +SSO via OpenID Connect/LDAP (Keycloak, Okta/Auth0, Google, AD, OpenLDAP). IAM estilo AWS. + +## Gestão de certificados + +TLS fim‑a‑fim; integração com gestor de certificados do CCE. + +## Monitorização e alertas + +Métricas Prometheus; Grafana/monitoring; alertas. + +## Logging e auditoria + +Auditoria de operações e erros; exportação para Elastic Stack/terceiros. diff --git a/docs/pt/features/industry/images/cold-backup-solution.png b/docs/pt/features/industry/images/cold-backup-solution.png new file mode 100644 index 0000000..f10bd73 Binary files /dev/null and b/docs/pt/features/industry/images/cold-backup-solution.png differ diff --git a/docs/pt/features/industry/images/multi-cloud-solution.png b/docs/pt/features/industry/images/multi-cloud-solution.png new file mode 100644 index 0000000..bee80e5 Binary files /dev/null and b/docs/pt/features/industry/images/multi-cloud-solution.png differ diff --git a/docs/pt/features/industry/images/ssd-hdd-solution.png b/docs/pt/features/industry/images/ssd-hdd-solution.png new file mode 100644 index 0000000..8ae0c7a Binary files /dev/null and b/docs/pt/features/industry/images/ssd-hdd-solution.png differ diff --git a/docs/pt/features/industry/images/tech-value-pyramid.png b/docs/pt/features/industry/images/tech-value-pyramid.png new file mode 100644 index 0000000..a63d912 Binary files /dev/null and b/docs/pt/features/industry/images/tech-value-pyramid.png differ diff --git a/docs/pt/features/industry/index.md b/docs/pt/features/industry/index.md new file mode 100644 index 0000000..d987251 --- /dev/null +++ b/docs/pt/features/industry/index.md @@ -0,0 +1,78 @@ +# Solução para produção industrial + +Armazenamento, inspeção de qualidade e rastreabilidade para volumes massivos de dados; preservação a longo prazo com otimização de custos. + +## Quatro desafios centrais + +| Dor | Cenários/Desafios | Necessidade do utilizador | +|-----|--------------------|---------------------------| +| Capacidade e escalabilidade | Sensores e equipamentos geram dados em PB; storage tradicional escala mal e é caro | Escala elástica com crescimento dinâmico; reduzir CAPEX/OPEX | +| Processamento em tempo real | Monitorização e manutenção preditiva exigem latências de ms; storage tradicional adiciona latência | Alto IOPS/throughput; suporte a analytics em tempo real e edge | +| Segurança e conformidade | Dados industriais sensíveis; conformidade (GDPR, ISO 27001, etc.) | Encriptação end‑to‑end, RBAC granular, auditoria completa | +| Dados heterogéneos | S3, NFS, bases de dados; silos e baixa utilização | Plataforma unificada multi‑protocolo com gestão centralizada | + +## Solução + +### Tiering SSD + HDD para reduzir custos + +![SSD e HDD](./images/ssd-hdd-solution.png) + +SSD para I/O intensivo e HDD para capacidade. Dados quentes em SSD e frios em HDD equilibram custo e desempenho. + +#### Vantagens do tiering + +- Desempenho: aceleração com SSD onde necessário +- Custo: HDD para o grosso dos dados frios +- Operação: políticas automáticas por ciclo de vida +- Escala: expansão por camadas e integração com cloud +- Resiliência: cópias e espelhamento +- Eficiência: menor consumo energético + +#### Comparativo SSD+HDD vs. soluções únicas + +| Item | Apenas SSD | Apenas HDD | Tiering SSD+HDD | +|------|------------|------------|------------------| +| Custo de mídia | Alto | Baixo | Misto (SSD p/ 20% dados quentes) | +| Latência | ~0,1 ms | 8–10 ms | ~0,15 ms em quente; frio sob consulta | +| Energia (1 PB/ano) | Elevada | Elevada | Otimizada (SSD baixo consumo + HDD hibernação) | +| Expansão | Caro | Gargalo de performance | Por camada (ex.: ampliar só HDD) | +| TCO 5 anos | Alto | Baixo | Intermédio (equilíbrio custo/perf.) | +| Cenários | Tempo real | Arquivo/backup | Cargas mistas (BD/ficheiros) | + +### Arquivo frio para reduzir custos + +![Arquivo frio](./images/cold-backup-solution.png) + +Mídias como ótico/fita reduzem custo para dados de baixa frequência e longa retenção, com consumo energético menor. + +#### Vantagens + +- Custo por GB reduzido em dados frios +- Retenção longa com poucas migrações +- Segurança e conformidade com encriptação e imutabilidade + +#### Comparativo (1 PB / 5 anos) + +| Mídia | Custo total | Energia | Vida útil | +|-------|-------------|---------|----------| +| Óptico | Otimizado | Baixo | 50+ anos | +| Fita | Médio | Médio | ~30 anos | +| HDD | Mais alto | Mais alto | ~5 anos | + +### Multicloud para otimizar custos + +![Multicloud](./images/multi-cloud-solution.png) + +Orquestração para colocar dados quentes em camadas de alto desempenho e frios em camadas económicas, usando interfaces padronizadas e caminhos ótimos por proximidade. + +#### Vantagens + +- Orquestração entre clouds +- Otimização de custo por políticas +- Aceleração com SSD para cargas críticas + +### Pirâmide de valor tecnológico + +![Pirâmide](./images/tech-value-pyramid.png) + +Baseado em armazenamento de objetos distribuído confiável e elástico, suporta produção inteligente fim‑a‑fim, QA assistido por IA e colaboração global de cadeia de fornecimento, impulsionando evolução para Indústria 4.0. diff --git a/docs/pt/features/integration/images/backup-1.png b/docs/pt/features/integration/images/backup-1.png new file mode 100644 index 0000000..07ccfd2 Binary files /dev/null and b/docs/pt/features/integration/images/backup-1.png differ diff --git a/docs/pt/features/integration/images/backup-2.png b/docs/pt/features/integration/images/backup-2.png new file mode 100644 index 0000000..c07bed9 Binary files /dev/null and b/docs/pt/features/integration/images/backup-2.png differ diff --git a/docs/pt/features/integration/images/backup-3.png b/docs/pt/features/integration/images/backup-3.png new file mode 100644 index 0000000..f97582d Binary files /dev/null and b/docs/pt/features/integration/images/backup-3.png differ diff --git a/docs/pt/features/integration/images/backup-4.png b/docs/pt/features/integration/images/backup-4.png new file mode 100644 index 0000000..2b60ff6 Binary files /dev/null and b/docs/pt/features/integration/images/backup-4.png differ diff --git a/docs/pt/features/integration/images/federation-1.png b/docs/pt/features/integration/images/federation-1.png new file mode 100644 index 0000000..6b02f0e Binary files /dev/null and b/docs/pt/features/integration/images/federation-1.png differ diff --git a/docs/pt/features/integration/images/federation-2.png b/docs/pt/features/integration/images/federation-2.png new file mode 100644 index 0000000..e846995 Binary files /dev/null and b/docs/pt/features/integration/images/federation-2.png differ diff --git a/docs/pt/features/integration/images/hybrid-1.png b/docs/pt/features/integration/images/hybrid-1.png new file mode 100644 index 0000000..1b93e7a Binary files /dev/null and b/docs/pt/features/integration/images/hybrid-1.png differ diff --git a/docs/pt/features/integration/images/hybrid-2.png b/docs/pt/features/integration/images/hybrid-2.png new file mode 100644 index 0000000..18f02fd Binary files /dev/null and b/docs/pt/features/integration/images/hybrid-2.png differ diff --git a/docs/pt/features/integration/images/hybrid-3.png b/docs/pt/features/integration/images/hybrid-3.png new file mode 100644 index 0000000..361e2a1 Binary files /dev/null and b/docs/pt/features/integration/images/hybrid-3.png differ diff --git a/docs/pt/features/integration/images/hybrid-4.png b/docs/pt/features/integration/images/hybrid-4.png new file mode 100644 index 0000000..b859603 Binary files /dev/null and b/docs/pt/features/integration/images/hybrid-4.png differ diff --git a/docs/pt/features/integration/images/identity-1.png b/docs/pt/features/integration/images/identity-1.png new file mode 100644 index 0000000..e0f32ff Binary files /dev/null and b/docs/pt/features/integration/images/identity-1.png differ diff --git a/docs/pt/features/integration/images/identity-2.png b/docs/pt/features/integration/images/identity-2.png new file mode 100644 index 0000000..e2b3a78 Binary files /dev/null and b/docs/pt/features/integration/images/identity-2.png differ diff --git a/docs/pt/features/integration/images/identity-3.png b/docs/pt/features/integration/images/identity-3.png new file mode 100644 index 0000000..f9031d1 Binary files /dev/null and b/docs/pt/features/integration/images/identity-3.png differ diff --git a/docs/pt/features/integration/images/integration-hero.svg b/docs/pt/features/integration/images/integration-hero.svg new file mode 100644 index 0000000..a2f4865 --- /dev/null +++ b/docs/pt/features/integration/images/integration-hero.svg @@ -0,0 +1,13 @@ + + + hbr 混合云备份 + + + + + + + + + + \ No newline at end of file diff --git a/docs/pt/features/integration/images/kms-1.png b/docs/pt/features/integration/images/kms-1.png new file mode 100644 index 0000000..4429540 Binary files /dev/null and b/docs/pt/features/integration/images/kms-1.png differ diff --git a/docs/pt/features/integration/images/kms-2.png b/docs/pt/features/integration/images/kms-2.png new file mode 100644 index 0000000..ddc1357 Binary files /dev/null and b/docs/pt/features/integration/images/kms-2.png differ diff --git a/docs/pt/features/integration/images/loadbalancer-1.png b/docs/pt/features/integration/images/loadbalancer-1.png new file mode 100644 index 0000000..d1bccbc Binary files /dev/null and b/docs/pt/features/integration/images/loadbalancer-1.png differ diff --git a/docs/pt/features/integration/images/loadbalancer-2.png b/docs/pt/features/integration/images/loadbalancer-2.png new file mode 100644 index 0000000..e42d308 Binary files /dev/null and b/docs/pt/features/integration/images/loadbalancer-2.png differ diff --git a/docs/pt/features/integration/images/loadbalancer-3.png b/docs/pt/features/integration/images/loadbalancer-3.png new file mode 100644 index 0000000..d1d2526 Binary files /dev/null and b/docs/pt/features/integration/images/loadbalancer-3.png differ diff --git a/docs/pt/features/integration/images/loadbalancer-4.png b/docs/pt/features/integration/images/loadbalancer-4.png new file mode 100644 index 0000000..4f587c4 Binary files /dev/null and b/docs/pt/features/integration/images/loadbalancer-4.png differ diff --git a/docs/pt/features/integration/images/ml-1.png b/docs/pt/features/integration/images/ml-1.png new file mode 100644 index 0000000..6ad1801 Binary files /dev/null and b/docs/pt/features/integration/images/ml-1.png differ diff --git a/docs/pt/features/integration/images/ml-2.png b/docs/pt/features/integration/images/ml-2.png new file mode 100644 index 0000000..b859603 Binary files /dev/null and b/docs/pt/features/integration/images/ml-2.png differ diff --git a/docs/pt/features/integration/images/ml-3.png b/docs/pt/features/integration/images/ml-3.png new file mode 100644 index 0000000..690c687 Binary files /dev/null and b/docs/pt/features/integration/images/ml-3.png differ diff --git a/docs/pt/features/integration/images/ml-4.png b/docs/pt/features/integration/images/ml-4.png new file mode 100644 index 0000000..1c2c3cb Binary files /dev/null and b/docs/pt/features/integration/images/ml-4.png differ diff --git a/docs/pt/features/integration/images/ml-5.png b/docs/pt/features/integration/images/ml-5.png new file mode 100644 index 0000000..f225a8e Binary files /dev/null and b/docs/pt/features/integration/images/ml-5.png differ diff --git a/docs/pt/features/integration/images/ml-6.png b/docs/pt/features/integration/images/ml-6.png new file mode 100644 index 0000000..a4fb0ab Binary files /dev/null and b/docs/pt/features/integration/images/ml-6.png differ diff --git a/docs/pt/features/integration/images/monitoring-1.png b/docs/pt/features/integration/images/monitoring-1.png new file mode 100644 index 0000000..5ad08d2 Binary files /dev/null and b/docs/pt/features/integration/images/monitoring-1.png differ diff --git a/docs/pt/features/integration/images/monitoring-2.png b/docs/pt/features/integration/images/monitoring-2.png new file mode 100644 index 0000000..6e6e400 Binary files /dev/null and b/docs/pt/features/integration/images/monitoring-2.png differ diff --git a/docs/pt/features/integration/images/monitoring-3.png b/docs/pt/features/integration/images/monitoring-3.png new file mode 100644 index 0000000..a1c12a6 Binary files /dev/null and b/docs/pt/features/integration/images/monitoring-3.png differ diff --git a/docs/pt/features/integration/images/monitoring-4.png b/docs/pt/features/integration/images/monitoring-4.png new file mode 100644 index 0000000..23e9161 Binary files /dev/null and b/docs/pt/features/integration/images/monitoring-4.png differ diff --git a/docs/pt/features/integration/images/notification-1.png b/docs/pt/features/integration/images/notification-1.png new file mode 100644 index 0000000..11ebe18 Binary files /dev/null and b/docs/pt/features/integration/images/notification-1.png differ diff --git a/docs/pt/features/integration/images/notification-2.png b/docs/pt/features/integration/images/notification-2.png new file mode 100644 index 0000000..92a3251 Binary files /dev/null and b/docs/pt/features/integration/images/notification-2.png differ diff --git a/docs/pt/features/integration/images/notification-3.png b/docs/pt/features/integration/images/notification-3.png new file mode 100644 index 0000000..6610c93 Binary files /dev/null and b/docs/pt/features/integration/images/notification-3.png differ diff --git a/docs/pt/features/integration/images/notification-4.png b/docs/pt/features/integration/images/notification-4.png new file mode 100644 index 0000000..5620f5a Binary files /dev/null and b/docs/pt/features/integration/images/notification-4.png differ diff --git a/docs/pt/features/integration/images/orchestrator-1.png b/docs/pt/features/integration/images/orchestrator-1.png new file mode 100644 index 0000000..e561729 Binary files /dev/null and b/docs/pt/features/integration/images/orchestrator-1.png differ diff --git a/docs/pt/features/integration/images/orchestrator-2.png b/docs/pt/features/integration/images/orchestrator-2.png new file mode 100644 index 0000000..0755e7e Binary files /dev/null and b/docs/pt/features/integration/images/orchestrator-2.png differ diff --git a/docs/pt/features/integration/images/orchestrator-3.png b/docs/pt/features/integration/images/orchestrator-3.png new file mode 100644 index 0000000..9964140 Binary files /dev/null and b/docs/pt/features/integration/images/orchestrator-3.png differ diff --git a/docs/pt/features/integration/index.md b/docs/pt/features/integration/index.md new file mode 100644 index 0000000..d682a4d --- /dev/null +++ b/docs/pt/features/integration/index.md @@ -0,0 +1,99 @@ +# Integrações com o RustFS + +O stack de dados moderno é interligado. Veja a lista de integrações e links para documentação relacionada. + +## Tipos de integração + +- 👥 Provedores de identidade externos – SSO e gestão de identidade +- 🔐 Gestão externa de chaves – KMS centralizado +- 📊 Monitorização e alertas – observabilidade contínua +- 🔔 Destinos de notificação – serviços de eventos +- 🌐 Federação – autenticação entre datacenters +- ⚙️ Orquestradores – plataformas cloud‑native +- ⚖️ Balanceadores de carga – distribuição e gestão de tráfego +- ☁️ Híbrido – suporte multicloud +- 🤖 ML e Big Data – integração com frameworks +- 💾 Backup – soluções de proteção de dados + +--- + +## Provedores de identidade externos + +Integração com IdPs confiáveis para SSO de apps e utilizadores. + +| | | | +|---|---|---| +| ![IdP 1](./images/identity-1.png) | ![IdP 2](./images/identity-2.png) | ![IdP 3](./images/identity-3.png) | + +## Gestão externa de chaves + +KMS para criar/gerir chaves e controlar seu uso centralmente. + +| | | +|---|---| +| ![KMS 1](./images/kms-1.png) | ![KMS 2](./images/kms-2.png) | + +## Monitorização e alertas + +Observabilidade para contentores e microserviços. + +| | | | | +|---|---|---|---| +| ![Mon 1](./images/monitoring-1.png) | ![Mon 2](./images/monitoring-2.png) | ![Mon 3](./images/monitoring-3.png) | ![Mon 4](./images/monitoring-4.png) | + +## Destinos de notificação + +Registo de operações para funções/lambda, pesquisa, analytics e auditoria. + +| | | | | +|---|---|---|---| +| ![Notif 1](./images/notification-1.png) | ![Notif 2](./images/notification-2.png) | ![Notif 3](./images/notification-3.png) | ![Notif 4](./images/notification-4.png) | + +## Federação + +Autenticação federada em implantações geodistribuídas. + +| | | +|---|---| +| ![Fed 1](./images/federation-1.png) | ![Fed 2](./images/federation-2.png) | + +## Orquestradores + +Suporte a plataformas cloud‑native para automatizar recursos (CPU/rede/discos). + +| | | | +|---|---|---| +| ![Orch 1](./images/orchestrator-1.png) | ![Orch 2](./images/orchestrator-2.png) | ![Orch 3](./images/orchestrator-3.png) | + +## Balanceadores de carga + +Para tráfego público: routing, descoberta, terminação SSL e shaping. + +| | | | | +|---|---|---|---| +| ![LB 1](./images/loadbalancer-1.png) | ![LB 2](./images/loadbalancer-2.png) | ![LB 3](./images/loadbalancer-3.png) | ![LB 4](./images/loadbalancer-4.png) | + +## Híbrido + +Do on‑prem à nuvem pública com S3; cache/CDN diante da nuvem para poupar banda e manter performance. + +| | | | | +|---|---|---|---| +| ![Hybrid 1](./images/hybrid-1.png) | ![Hybrid 2](./images/hybrid-2.png) | ![Hybrid 3](./images/hybrid-3.png) | ![Hybrid 4](./images/hybrid-4.png) | + +## ML e Big Data + +Integrações nativas com frameworks de analytics/ML. + +| | | | +|---|---|---| +| ![ML 1](./images/ml-1.png) | ![ML 2](./images/ml-2.png) | ![ML 3](./images/ml-3.png) | +| ![ML 4](./images/ml-4.png) | ![ML 5](./images/ml-5.png) | ![ML 6](./images/ml-6.png) | + +## Backup + +Com S3, object storage é alvo padrão dos apps de backup modernos. Integrações com vários fornecedores líderes. + +| | | | | +|---|---|---|---| +| ![Backup 1](./images/backup-1.png) | ![Backup 2](./images/backup-2.png) | ![Backup 3](./images/backup-3.png) | ![Backup 4](./images/backup-4.png) | diff --git a/docs/pt/features/lifecycle/images/s9-1.png b/docs/pt/features/lifecycle/images/s9-1.png new file mode 100644 index 0000000..2d777c2 Binary files /dev/null and b/docs/pt/features/lifecycle/images/s9-1.png differ diff --git a/docs/pt/features/lifecycle/images/s9-2.png b/docs/pt/features/lifecycle/images/s9-2.png new file mode 100644 index 0000000..751c58e Binary files /dev/null and b/docs/pt/features/lifecycle/images/s9-2.png differ diff --git a/docs/pt/features/lifecycle/images/s9-3.png b/docs/pt/features/lifecycle/images/s9-3.png new file mode 100644 index 0000000..3478819 Binary files /dev/null and b/docs/pt/features/lifecycle/images/s9-3.png differ diff --git a/docs/pt/features/lifecycle/images/s9-4.png b/docs/pt/features/lifecycle/images/s9-4.png new file mode 100644 index 0000000..1c1667e Binary files /dev/null and b/docs/pt/features/lifecycle/images/s9-4.png differ diff --git a/docs/pt/features/lifecycle/index.md b/docs/pt/features/lifecycle/index.md new file mode 100644 index 0000000..e42e1d6 --- /dev/null +++ b/docs/pt/features/lifecycle/index.md @@ -0,0 +1,41 @@ +# Gestão do ciclo de vida e tiering de dados + +À medida que os dados crescem, otimizar conjuntamente acesso, segurança e economia deixa de ser opcional. A gestão do ciclo de vida resolve esse desafio. O RustFS oferece um conjunto de funcionalidades para proteger dados dentro e entre nuvens (pública/privada). Ferramentas empresariais incluem versionamento, bloqueio de objetos e componentes relacionados. + +## Expiração de objetos + +Os dados não precisam existir para sempre. Regras de ciclo de vida permitem definir por quanto tempo os objetos permanecem no disco antes de serem eliminados. O tempo pode ser um número de dias ou uma data específica. + +As regras são definidas por bucket e permitem filtros por objeto/labels. É possível aplicar a regra a todo o bucket (sem filtros) ou criar múltiplas regras para comportamentos mais complexos. + +As regras também se aplicam a buckets com versionamento, com opções específicas: por exemplo, definir expiração apenas para versões não atuais, reduzindo custo sem perder proteção, ou remover objetos cujo único remanescente seja um delete marker. + +As regras respeitam WORM/Legal Hold: objetos bloqueados permanecem até expirar ou serem desbloqueados. Depois disso, as regras de expiração voltam a aplicar‑se normalmente. + +As regras do RustFS são compatíveis em sintaxe e função com AWS Lifecycle Management. Pode importar regras existentes em JSON para migração facilitada. + +## Tiering baseado em políticas + +O RustFS permite configurar tiering programático, movendo objetos entre estados/classes com base em variáveis (tipicamente tempo/frequência de acesso). Tiering otimiza custo/desempenho face a padrões de acesso em mudança. + +## Entre mídias de armazenamento + +O caso mais comum: o RustFS abstrai a mídia e otimiza por performance/custo. Dados “quentes” podem residir em NVMe/SSD e, após algum tempo, mover para HDD ou camadas mais frias, conforme o cenário. + +![Tiering entre mídias](images/s9-2.png) + +## Entre tipos de nuvem + +Use storage e computação de nuvem pública como camada adicional da nuvem privada. Workloads nearline de alto desempenho residem no privado; à medida que crescem e a exigência de performance cai, mova dados para cold storage na nuvem pública para otimizar custo. + +Execute RustFS tanto na nuvem privada quanto na pública. Com replicação, mova dados para opções baratas e proteja/aceda via RustFS na nuvem pública. Aqui, a nuvem pública torna‑se “storage burro” do RustFS, tal como JBOD; evita substituições e custos de fita. + +![Tiering entre nuvens](images/s9-3.png) + +## Em nuvem pública + +O RustFS frequentemente atua como storage primário de aplicações. O aplicativo apenas conhece o endpoint; o RustFS decide onde os dados pertencem, movendo blocos para objeto e escolhendo a camada que cumpre metas de performance/economia. + +O RustFS combina camadas e seleciona mídia adequada para melhor economia sem afetar performance. O app endereça objetos via RustFS; políticas movem objetos entre camadas e mantêm metadados em bloco. + +![Tiering em nuvem pública](images/s9-4.png) diff --git a/docs/pt/features/logging/images/s7-1.png b/docs/pt/features/logging/images/s7-1.png new file mode 100644 index 0000000..9be927f Binary files /dev/null and b/docs/pt/features/logging/images/s7-1.png differ diff --git a/docs/pt/features/logging/images/s7-2.png b/docs/pt/features/logging/images/s7-2.png new file mode 100644 index 0000000..8cdf803 Binary files /dev/null and b/docs/pt/features/logging/images/s7-2.png differ diff --git a/docs/pt/features/logging/index.md b/docs/pt/features/logging/index.md new file mode 100644 index 0000000..69b8116 --- /dev/null +++ b/docs/pt/features/logging/index.md @@ -0,0 +1,62 @@ +--- +title: "Registo e auditoria" +description: "Métricas, registos, auditoria e arquitetura de observabilidade no RustFS" +--- + +# Registo e auditoria + +Para acompanhar o estado e o desempenho de qualquer sistema, métricas e logs são críticos. O RustFS oferece monitorização detalhada de desempenho, métricas e registo por operação, proporcionando visibilidade completa do cluster. + +## Funcionalidades + +### Métricas de monitorização + +Fornece recolha abrangente de métricas de sistema e desempenho. + +### Registo + +Regista informações detalhadas de cada operação, suportando trilhos de auditoria. + +## Monitorização de métricas + +O RustFS exporta métricas finas de HW/SW por endpoint compatível com Prometheus. O Prometheus, com modelo de dados multidimensional e séries temporais (nome/pares chave‑valor), é usado com Grafana para visualização. O ecossistema inclui integrações para encaminhar métricas para armazenamento/mensageria/alertas. + +Expõe saúde de discos/nós, capacidade total/disco, etc. Tirando partido do Prometheus como plataforma líder de recolha/análise, o RustFS foca‑se no core em vez de múltiplos adaptadores proprietários de monitorização. + +O operador Kubernetes do RustFS pode implementar/configurar/gerir Prometheus por tenant. Organizações podem apontar o seu Prometheus (ou compatíveis) para cada tenant e centralizar monitorização em múltiplas clouds/DCs/ferramentas. + +Inclui ainda endpoint de health‑check a nível de nó/cluster para verificar quorum de leitura/escrita via simples `curl`. + +## Logs de auditoria + +Com auditoria ativa, o RustFS gera um log por operação com ID único e metadados de cliente/objeto/bucket. Os logs são enviados para webhook HTTP/HTTPS configurado. Adaptadores personalizados podem atender requisitos específicos de destino. + +A auditoria é configurável via consola e via `mc`. Em Kubernetes, o operador configura a integração com LogSearch para visualização dos logs. + +O RustFS suporta notificações tipo Lambda, enviando eventos de bucket/objeto para terceiros (serverless/FaaS). Via webhook, suporta RabbitMQ, Kafka, Elasticsearch e serviços arbitrários. + +Também suporta tracing em tempo real de operações HTTP/S via consola e `mc admin trace`. + +## Arquitetura + +**O RustFS expõe métricas por HTTP(S) compatível com Prometheus; o serviço Prometheus efetua pull/push. O operador Kubernetes implementa Prometheus por tenant para scraping. Organizações podem usar Prometheus centralizado.** + +![Arquitetura 1](images/s7-1.png) + +As notificações Lambda empurram eventos para Kafka, Elasticsearch ou PostgreSQL. Administradores definem regras de notificação ao nível do bucket com filtros granulares de eventos/objetos. + +![Arquitetura 2](images/s7-2.png) + +## Requisitos + +### Para métricas + +BYO Prometheus ou usar o operador para deploy por tenant. + +### Para pesquisa de logs + +BYO PostgreSQL ou usar o operador para deploy por tenant. + +### Para logs + +Suporta destinos de notificação de terceiros. diff --git a/docs/pt/features/openshift/images/sec1-1.png b/docs/pt/features/openshift/images/sec1-1.png new file mode 100644 index 0000000..07116ed Binary files /dev/null and b/docs/pt/features/openshift/images/sec1-1.png differ diff --git a/docs/pt/features/openshift/index.md b/docs/pt/features/openshift/index.md new file mode 100644 index 0000000..bf0aa1d --- /dev/null +++ b/docs/pt/features/openshift/index.md @@ -0,0 +1,55 @@ +# RustFS para Red Hat OpenShift Container Platform + +## Três razões para executar RustFS no OpenShift + +- Camada de armazenamento consistente em cenários híbridos/multicloud +- Produto cloud‑native de alto desempenho no Kubernetes (público/privado/edge) +- No OpenShift, mantém controlo da pilha e evita lock‑in + +O Red Hat OpenShift é uma plataforma Kubernetes empresarial com operações automatizadas de pilha completa para gerir implantações híbridas, multicloud e edge. Inclui SO empresarial Linux, runtime de contentores, rede, monitorização, registo e soluções de identidade/autorização. + +O RustFS integra‑se nativamente ao OpenShift para operar armazenamento de objetos multi‑inquilino em grande escala. O RustFS Operator funciona com OpenShift Cluster Manager CLI, registo Quay e restante toolchain. + +![Arquitetura RustFS](images/sec1-1.png) + +Por ser Kubernetes‑native e compatível com S3 desde a origem, o RustFS oferece armazenamento de objetos consistente, performante e escalável. Os developers obtêm storage persistente compatível com S3 para apps cloud‑native no OpenShift. Diferente do S3, o RustFS escala entre infraestruturas híbridas/multicloud mantendo gestão no ecossistema OpenShift, sem lock‑in de cloud pública. + +## Integração nativa do RustFS Operator com OpenShift + +### Visão geral + +- Classes de armazenamento e tiering +- Load balancer externo +- Gestão de chaves (KMS) +- Gestão de identidade +- Gestão de certificados +- Monitorização e alertas +- Logging e auditoria + +## Classes de armazenamento e tiering + +Tiering entre NVMe/HDD/cloud para equilibrar custo e performance. O RustFS migra objetos envelhecidos para camadas mais económicas mantendo namespace único e movimentos transparentes por políticas. + +## Load balancer externo + +Tráfego HTTP/REST com suporte a Ingress compatível com Kubernetes (hardware/software). NGINX é opção popular. Instale via OperatorHub/Marketplace e exponha tenants com anotações. + +## Gestão de chaves (KMS) + +Recomenda‑se encriptação por padrão em todos os buckets. RustFS suporta AES‑256‑GCM/ChaCha20‑Poly1305 com overhead mínimo e modos SSE‑KMS/SSE‑S3/SSE‑C. O KMS inicializa KES por tenant para encriptação por objeto. + +## Gestão de identidade + +SSO via OpenID Connect/LDAP (Keycloak, Okta/Auth0, Google, Facebook, AD, OpenLDAP). RustFS fornece utilizadores/grupos/papéis/políticas/STS ao estilo AWS IAM, criando uma camada de IAM unificada. + +## Gestão de certificados + +Todo tráfego app↔RustFS e inter‑nós usa TLS. Integração com gestor de certificados do OpenShift para provisionar/renovar automaticamente por tenant (isolado por namespace). + +## Monitorização e alertas + +Exponha métricas Prometheus (capacidade, acessos, etc.). Use Grafana ou o monitoring do projeto openshift‑user‑workload. Defina baselines e alertas (PagerDuty/Freshservice/SNMP). + +## Logging e auditoria + +A auditoria regista todas as operações de objetos; erros de console ajudam no troubleshooting. Suporta envio para Elastic Stack ou terceiros. diff --git a/docs/pt/features/qcloud/images/sec1-1.png b/docs/pt/features/qcloud/images/sec1-1.png new file mode 100644 index 0000000..07116ed Binary files /dev/null and b/docs/pt/features/qcloud/images/sec1-1.png differ diff --git a/docs/pt/features/qcloud/index.md b/docs/pt/features/qcloud/index.md new file mode 100644 index 0000000..9e7450c --- /dev/null +++ b/docs/pt/features/qcloud/index.md @@ -0,0 +1,55 @@ +# RustFS para Tencent Cloud TKE Kubernetes Service + +## Três razões para executar RustFS na Tencent Cloud + +- Camada de armazenamento consistente em cenários híbridos/multicloud +- Produto cloud‑native de alto desempenho no Kubernetes (público/privado/edge) +- Controle da pilha no TKE, evitando lock‑in + +O TKE é um serviço gerido para executar Kubernetes na Tencent Cloud sem gerir control plane ou nós. + +O RustFS oferece armazenamento de objetos portátil e performante nas principais plataformas Kubernetes (ACK, Tanzu, Azure, GCP, TKE). No TKE, integra‑se nativamente para operar storage multi‑inquilino em escala, como alternativa ao S3. + +![Arquitetura RustFS](images/sec1-1.png) + +Diferente do S3, o RustFS permite escalar aplicações entre nuvens sem reescritas dispendiosas. Cloud‑native e contentorizado, implanta‑se facilmente sem skills especializados. + +## Integração nativa do RustFS Operator com TKE + +### Visão geral + +- Classes de armazenamento e tiering +- Load balancer externo +- Gestão de chaves (KMS) +- Gestão de identidade +- Gestão de certificados +- Monitorização e alertas +- Logging e auditoria + +## Classes de armazenamento e tiering + +Tiering entre NVMe/HDD/cloud com namespace único e políticas de movimentação. + +## Load balancer externo + +Suporte a Ingress compatível com Kubernetes (inclui NGINX). Instale via marketplace e exponha tenants com anotações. + +## Gestão de chaves (KMS) + +Encriptação por padrão recomendada; suporta AES‑256‑GCM/ChaCha20‑Poly1305 e SSE‑KMS/SSE‑S3/SSE‑C. KMS inicializa KES por tenant. + +## Gestão de identidade + +SSO via OpenID Connect/LDAP (Keycloak, Okta/Auth0, Google, AD, OpenLDAP). IAM ao estilo AWS (utilizadores/grupos/papéis/políticas/STS). + +## Gestão de certificados + +TLS para todo tráfego; integração com gestor de certificados para provisionamento/renovação automático por tenant. + +## Monitorização e alertas + +Métricas Prometheus; visualize com Grafana/monitoring do cluster; configure alertas. + +## Logging e auditoria + +Registo de operações e erros de console; exportação para Elastic Stack/terceiros. diff --git a/docs/pt/features/quantitative-trading/images/ai-factor-mining.png b/docs/pt/features/quantitative-trading/images/ai-factor-mining.png new file mode 100644 index 0000000..da6cbd4 Binary files /dev/null and b/docs/pt/features/quantitative-trading/images/ai-factor-mining.png differ diff --git a/docs/pt/features/quantitative-trading/images/files-icon.png b/docs/pt/features/quantitative-trading/images/files-icon.png new file mode 100644 index 0000000..0b1fe20 Binary files /dev/null and b/docs/pt/features/quantitative-trading/images/files-icon.png differ diff --git a/docs/pt/features/quantitative-trading/images/hft-strategy.png b/docs/pt/features/quantitative-trading/images/hft-strategy.png new file mode 100644 index 0000000..5ce40a0 Binary files /dev/null and b/docs/pt/features/quantitative-trading/images/hft-strategy.png differ diff --git a/docs/pt/features/quantitative-trading/images/regulatory-compliance.png b/docs/pt/features/quantitative-trading/images/regulatory-compliance.png new file mode 100644 index 0000000..edcd0c9 Binary files /dev/null and b/docs/pt/features/quantitative-trading/images/regulatory-compliance.png differ diff --git a/docs/pt/features/quantitative-trading/images/scaling-icon.png b/docs/pt/features/quantitative-trading/images/scaling-icon.png new file mode 100644 index 0000000..6455353 Binary files /dev/null and b/docs/pt/features/quantitative-trading/images/scaling-icon.png differ diff --git a/docs/pt/features/quantitative-trading/images/security-icon.png b/docs/pt/features/quantitative-trading/images/security-icon.png new file mode 100644 index 0000000..79efca0 Binary files /dev/null and b/docs/pt/features/quantitative-trading/images/security-icon.png differ diff --git a/docs/pt/features/quantitative-trading/images/speed-icon.png b/docs/pt/features/quantitative-trading/images/speed-icon.png new file mode 100644 index 0000000..b1f034d Binary files /dev/null and b/docs/pt/features/quantitative-trading/images/speed-icon.png differ diff --git a/docs/pt/features/quantitative-trading/index.md b/docs/pt/features/quantitative-trading/index.md new file mode 100644 index 0000000..037e33b --- /dev/null +++ b/docs/pt/features/quantitative-trading/index.md @@ -0,0 +1,76 @@ +# Solução de armazenamento para trading quantitativo + +Arquitetura inteligente para HFT e backtesting de estratégias, suportando milhões de IOPS e acesso em ms a dados Tick. + +## Desafios do setor + +| Categoria | Limitações tradicionais | Necessidade | Impacto | +|-----------|-------------------------|------------|---------| +| Gestão de dados | Armazenamento mono‑protocolo | Acesso unificado S3+POSIX+NFS | Ciclo de iteração aumenta | +| Métricas de performance | IOPS limitados p/ pequenos ficheiros | Múltiplos milhões de IOPS com baixa latência | Menos slippage | +| Custo de storage | Dados frios caros | Tiering económico | Orçamento reduzido | + +## Por que RustFS + +### Resposta rápida + +- Aceleração de rede e caminhos de dados eficientes para latência sub‑ms e alto throughput +- Backtesting acelerado + +### Muitos ficheiros + +- Agregação inteligente de pequenos ficheiros em objetos lógicos; escala para centenas de mil milhões de ficheiros +- Pesquisa de metadados eficiente + +### Escala elástica + +- Híbrido: SSD local para quente; arquivo automático na cloud para frio +- Capacidade com escala linear + +### Segurança financeira + +- Encriptação com baixo overhead +- DR geográfico com RTO reduzido + +## Soluções + +### Desenvolvimento de estratégias de alta frequência + +- Interface de mapeamento de memória (mmap) para C++/Python aceder aos dados de mercado + +### AI para fatores + +- Integração com TensorFlow/PyTorch; datasets mapeados para caminhos S3 + +### Conformidade regulatória + +- WORM para imutabilidade de registos de transação +- Auditoria integrada para alto volume de eventos + +## Conformidade e segurança + +- Criptografia certificável e suites duplas (conforme exigência) +- Replicação geográfica para requisitos de DR +- Integração com Splunk/Elastic para auditoria + +## Comparativo + +| Dimensão | Tradicional | Com RustFS | Valor | +|---------|-------------|------------|-------| +| Order flow | IOPS limitados | IOPS superiores | Menos risco em picos | +| Compressão | Taxa moderada | Taxas elevadas (ex.: ZSTD) | Redução de custo | +| Failover | Segundos | Sub‑segundo | Menos penalidades | + +## Serviços + +### Deploy + +- Appliance (RustFS pré‑instalado) ou software + +### Otimização + +- Guia de design de data lake quantitativo e consultoria + +### Ecossistema + +- Integrações com múltiplas plataformas quantitativas diff --git a/docs/pt/features/replication/images/s6-1.png b/docs/pt/features/replication/images/s6-1.png new file mode 100644 index 0000000..41fe8f5 Binary files /dev/null and b/docs/pt/features/replication/images/s6-1.png differ diff --git a/docs/pt/features/replication/images/s6-2.png b/docs/pt/features/replication/images/s6-2.png new file mode 100644 index 0000000..fbab173 Binary files /dev/null and b/docs/pt/features/replication/images/s6-2.png differ diff --git a/docs/pt/features/replication/index.md b/docs/pt/features/replication/index.md new file mode 100644 index 0000000..04d0bc4 --- /dev/null +++ b/docs/pt/features/replication/index.md @@ -0,0 +1,80 @@ +# Replicação multi‑site ativo‑ativo para armazenamento de objetos + +## Replicação ativa para armazenamento de objetos + +![Replicação de armazenamento de objetos](images/s6-1.png) + +Replicação ativa é requisito crítico em produção. O RustFS oferece essa capacidade com granularidade por bucket: + +O RustFS suporta replicação síncrona e quase síncrona, conforme arquitetura e taxa de alterações. Em todos os casos, busca consistência tão estrita quanto possível (respeitando banda/latência). + +## Replicação no RustFS para resiliência em grande escala + +Inclui: + +- ✅ Objetos (encriptados ou não) e metadados associados (gravados atomicamente) +- ✅ Versionamento +- ✅ Labels de objetos (se houver) +- ✅ Informação de retenção/lock S3 (se houver) + +## Capacidades‑chave + +### Fonte e destino com mesmo nome de bucket + +Necessário para failover transparente sem interrupção. + +### Lock/retention copiados automaticamente entre origem/destino + +Mantém integridade/conformidade durante replicação. + +### Quase síncrona + +Atualiza imediatamente após mutações no bucket. Consistência estrita intra‑DC e eventual entre DCs. + +### Notificações + +Eventos de falha de replicação para subscrição por apps/equipa de operações. + +## Considerações para ativo‑ativo + +Projetos devem considerar infraestrutura, banda, latência, resiliência e escala: + +### Base + +Hardware idêntico em ambos os lados é recomendado. Heterogeneidade aumenta complexidade e dificulta troubleshooting. + +### Banda + +A banda ideal depende da taxa de entrada de dados. Se insuficiente nos picos, mudanças serão enfileiradas e sincronizadas depois. + +### Latência + +Após banda, latência (RTT) é crucial. Objetivo: minimizar RTT dentro do orçamento de banda. Recomendação: RTT ≤ 20 ms e perda ≤ 0,01%. + +### Arquitetura + +Atualmente recomenda‑se replicação entre dois DCs. Mais DCs é possível, mas complexidade/compromissos crescem. + +## Deploy em grande escala + +Suporta grandes implantações por DC (origem/destino). Escala depende das considerações acima. + +![Arquitetura em grande escala](images/s6-2.png) + +## FAQ + +### O que acontece se o destino falhar? + +A origem armazena alterações e sincroniza ao voltar. O tempo até full sync depende da duração da falha, nº de mudanças, banda e latência. + +### Como fica a imutabilidade? + +É suportada. Em ativo‑ativo, só é garantida se o objeto for versionado. Não é possível desativar versionamento na origem. Pausar versionamento no destino leva a falhas de replicação. + +### E se versionamento for pausado ou divergir? + +Replicação pode falhar. Para desativar versionamento na origem, primeiro remova a configuração de replicação. Versionamento desativado no destino quebrará a replicação. + +### E se object lock não estiver ativo em ambos? + +Object lock deve estar ativo em origem e destino. Casos extremos (recriar bucket destino sem lock) podem causar falhas silenciosas ou inconsistências. diff --git a/docs/pt/features/s3-compatibility/images/s1-1.png b/docs/pt/features/s3-compatibility/images/s1-1.png new file mode 100644 index 0000000..3db2942 Binary files /dev/null and b/docs/pt/features/s3-compatibility/images/s1-1.png differ diff --git a/docs/pt/features/s3-compatibility/images/s1-2.png b/docs/pt/features/s3-compatibility/images/s1-2.png new file mode 100644 index 0000000..7ae13f1 Binary files /dev/null and b/docs/pt/features/s3-compatibility/images/s1-2.png differ diff --git a/docs/pt/features/s3-compatibility/images/s1-4.png b/docs/pt/features/s3-compatibility/images/s1-4.png new file mode 100644 index 0000000..454caa0 Binary files /dev/null and b/docs/pt/features/s3-compatibility/images/s1-4.png differ diff --git a/docs/pt/features/s3-compatibility/images/s1-5.png b/docs/pt/features/s3-compatibility/images/s1-5.png new file mode 100644 index 0000000..626032b Binary files /dev/null and b/docs/pt/features/s3-compatibility/images/s1-5.png differ diff --git a/docs/pt/features/s3-compatibility/index.md b/docs/pt/features/s3-compatibility/index.md new file mode 100644 index 0000000..e765231 --- /dev/null +++ b/docs/pt/features/s3-compatibility/index.md @@ -0,0 +1,44 @@ +--- +title: "Compatibilidade com Amazon S3" +description: "RustFS compatível com S3 para workloads multi‑cloud e bare metal" +--- + +# Compatibilidade com Amazon S3 + +A compatibilidade S3 é essencial para aplicações cloud‑native. Com uma comunidade vasta e foco em API, o RustFS oferece uma implementação S3 amplamente testada e adotada como alternativa ao AWS S3. + +## RustFS e API S3 – desenhado para multi‑cloud + +Desde o início, o RustFS definiu‑se pelo compromisso com o S3. Como um dos primeiros a adotar S3 V2/V4 e focado nesse protocolo, a comunidade assegura o mais alto nível de compatibilidade. Sendo o padrão de facto na cloud, o S3 permite operar e interoperar em público/privado/data center/multi‑cloud/híbrido/borda. + +## S3 para híbrido e multi‑cloud + +A compatibilidade multi/híbrida passa por S3. Como API RESTful, o S3 mudou a interação entre aplicações, dados e infraestrutura. O ecossistema cloud‑native (contentores/Kubernetes) é construído em torno de APIs RESTful, enquanto POSIX torna‑se legado. + +Na prática, armazenamento e aplicações S3‑compatíveis correm em qualquer lugar: clouds públicas (Google/Azure/AWS), privadas (OpenShift, Tanzu) e bare metal. Com ILM via S3, as empresas otimizam operações entre ambientes. + +## S3 para bare metal + +Em arquiteturas híbridas, a cloud privada é um bloco fundamental; portanto, S3 é igualmente crítico para workloads locais (analytics, artefactos, arquivo, etc.). Com RustFS, a compatibilidade S3 é idêntica em qualquer localização, com a mesma performance. + +## Vantagens do armazenamento de objetos escalável + +Nem toda compatibilidade S3 é igual. Muitos fornecedores suportam apenas subconjuntos da API, causando falhas. Outros limitam por software proprietário/appliances. O RustFS valida a compatibilidade com base em milhares de utilizadores e combinações de HW/SW, com lançamentos semanais e correções rápidas. + +Há relatos de que até a Amazon usa o RustFS para testar compatibilidade S3 de terceiros. + +### S3 Select + +![S3 Select](images/s1-4.png) + +O desempenho requerido por consultas complexas do S3 Select é atendido pelas otimizações SIMD do RustFS, suportando CSV/Parquet/JSON em cargas de grande escala. + +### Assinatura AWS V4 + +![Amazon Signature V4](images/s1-5.png) + +Clientes e aplicações autenticam‑se para aceder às APIs do RustFS. O RustFS suporta AWS Signature V4 (mantendo V2 legado). A autorização usa políticas compatíveis com AWS IAM. + +## API AWS S3 e RustFS + +O RustFS é um dos armazenamentos de objetos mais rápidos, e com compatibilidade S3 cobre um amplo conjunto de casos: repositórios (GitHub/GitLab), analytics (MongoDB, ClickHouse, MariaDB, CockroachDB, Teradata), arquivo/backup/DR e workloads de IA/ML (KubeFlow/TensorFlow). Aplicações escritas para S3 correm em qualquer lugar, viabilizando verdadeira multi‑cloud e replicação eficiente. diff --git a/docs/pt/features/small-file/images/memory-optimization.png b/docs/pt/features/small-file/images/memory-optimization.png new file mode 100644 index 0000000..0fcbbff Binary files /dev/null and b/docs/pt/features/small-file/images/memory-optimization.png differ diff --git a/docs/pt/features/small-file/index.md b/docs/pt/features/small-file/index.md new file mode 100644 index 0000000..cdf9ef6 --- /dev/null +++ b/docs/pt/features/small-file/index.md @@ -0,0 +1,33 @@ +# Otimização para pequenos ficheiros + +> Armazenamento de objetos em memória para workloads de ultra‑alta performance + +Use DRAM do servidor para criar um pool de memória distribuída partilhada para workloads com requisitos elevados de IOPS e throughput. + +## Contexto + +A otimização para pequenos ficheiros do RustFS é ideal para workloads de IOPS/throughput, cada vez mais comuns em AI/ML. Sem cache, o I/O pode se tornar gargalo para GPUs. + +Com cache empresarial, buckets com datasets de treino/validação/teste podem residir em memória. + +## Funcionalidades + +### 🗃️ Cache dedicada de objetos + +Se o objeto não estiver na cache, é obtido do storage, armazenado para pedidos futuros e devolvido ao chamador. + +### 💾 Hashing consistente + +Distribui dados de objetos em nós de cache (pares) com hashing consistente. Facilita localizar por chave, equilibra carga e minimiza reshuffling quando nós entram/saem. + +### 🧹 Gestão de memória por janela deslizante + +Mantém o tamanho total da cache dentro do limite configurado; remove objetos menos recentes quando necessário. + +### 🔄 Atualização automática de versões + +Se um objeto em cache for atualizado no storage, a cache recebe a nova versão automaticamente. + +### 🧩 Integração transparente de API + +É uma extensão interna do RustFS; nenhuma API nova é necessária. Se o objeto estiver em cache, é servido de lá; se não, é buscado, devolvido e colocado na cache para próximos acessos. diff --git a/docs/pt/features/sql-server/index.md b/docs/pt/features/sql-server/index.md new file mode 100644 index 0000000..01ca469 --- /dev/null +++ b/docs/pt/features/sql-server/index.md @@ -0,0 +1,271 @@ +# Execute o SQL Server 2022 em qualquer lugar + +Tire partido do RustFS com Tabelas Externas e PolyBase para executar o SQL Server 2022 em qualquer cloud (pública, privada ou edge). + +## Qualquer‑para‑qualquer, a qualquer momento + +Com o SQL Server 2022, consulte/análise múltiplas fontes de dados residindo no RustFS a partir de qualquer instância (cloud pública, privada ou edge). + +### Ambientes suportados + +- AWS +- GCP +- Azure +- VMware Tanzu +- Red Hat OpenShift +- HPE Ezmeral +- SUSE Rancher +- Bare‑metal tradicional + +### Acesso unificado a dados + +Via interface S3 compatível do RustFS, o SQL Server 2022 pode: + +- Aceder dados em múltiplas clouds +- Eliminar silos +- Oferecer experiência de consulta consistente +- Reduzir complexidade de integração + +## Ligue‑se aos dados, não os mova + +Com Tabelas Externas, use todo o poder do SQL Server sem mover dados. + +### Vantagens do PolyBase + +Permite usar T‑SQL para consultar dados do SQL Server e de outras bases: + +#### Fontes suportadas + +- SQL Server (on‑prem/cloud) +- Oracle +- Teradata +- MongoDB +- S3 API (via RustFS) + +#### Benefícios + +1. Zero data movement +2. Linguagem unificada (T‑SQL) +3. Acesso em tempo real +4. Menor custo de storage (evita duplicação) + +### Consolidação de silos + +RustFS oferece acesso uniforme entre hyperscalers. Com SQL Server 2022 + RustFS: + +- Aceda dados dispersos +- Obtenha insights integrados +- Vista unificada +- Integrações simplificadas + +## Performance em grande escala + +### Características + +Use SQL Server 2022 sobre todos os dados da organização: + +#### Escala ilimitada + +- Localização indiferente +- Suporte a múltiplos PB +- Consultas rápidas +- Alta concorrência + +#### Otimizações + +Com o desempenho do RustFS: + +1. Alto throughput +2. Baixa latência +3. Cache inteligente +4. Balanceamento de carga + +### Melhor utilização de recursos + +- Maximiza investimento no SQL Server +- Maximiza valor do cluster RustFS +- Liberta valor dos dados + +## Backup e recuperação + +### Casos de uso + +Backup/restore com múltiplas arquiteturas e configurações: + +- Arquiteturas diversas +- Configuração flexível +- Escalável com crescimento do negócio + +#### Recuperação rápida + +- Redução drástica do tempo de recuperação +- Alta disponibilidade +- Integridade dos dados +- Automação + +### Estratégias + +- Incremental +- Diferencial +- Completo +- Recuperação imediata + +## Seguro e disponível + +### Identidade e autorização + +Integração com IDPs de terceiros para: + +- Gestão centralizada de identidades +- SSO +- MFA +- Mapeamento de papéis + +#### Controlo de acesso + +- Princípio do menor privilégio +- Revisões periódicas +- Logging de acessos +- Deteção de anomalias + +### PBAC (Policy‑Based Access Control) + +- Controlo ao nível de recursos +- Atribuição dinâmica +- Herança de políticas +- Conformidade + +#### Segurança + +- Encriptação em trânsito/repouso +- Isolamento de rede +- Deteção de ameaças +- Resposta a incidentes + +## Resiliência + +### DR + +Replicação contínua para/da cloud: + +- Sincronização quase em tempo real +- Bidirecional +- Resolução de conflitos +- Failover + +#### Tiering + +- NVMe para quente +- Camadas intermédias +- Cold/arquivo +- Automação + +### Processamento de dados + +- T‑SQL +- Spark +- Análise híbrida +- Streaming + +#### Alta disponibilidade + +- Multi‑site +- Ativo‑ativo +- Consistência +- Recuperação de falhas de cloud + +## Streaming no edge + +Com Tabelas Externas, crie pipelines de streaming com dados no RustFS (cloud/on‑prem). + +### Tempo real + +- Ingestão contínua +- Pré‑processamento +- Armazenamento eficiente +- Query otimizada + +#### Consultas em tempo real + +- Sem batch +- Insights imediatos +- Menos latência +- Melhor experiência + +### Edge computing + +- Baixa latência +- Otimização de banda +- Operação intermitente +- Decisão local + +#### Casos + +- IoT +- Monitorização em tempo real +- Manutenção preditiva +- Manufatura inteligente + +## Cloud como modelo operacional + +- Contentores +- Kubernetes +- Automação +- APIs +- Compatibilidade S3 + +#### Interface unificada + +- Simplifica desenvolvimento +- Reduz curva de aprendizagem +- Portabilidade +- Evita lock‑in + +### Compatibilidade com frameworks AI/ML + +- TensorFlow +- PyTorch +- Scikit‑learn +- Apache Spark + +## Dados no edge com IA + +- Binário pequeno +- Desempenho otimizado +- Baixo consumo +- Notificações de bucket e Object Lambda + +### Workloads AI/ML + +- Políticas de ciclo de vida automatizadas +- Otimização de custo +- Retenção/eliminação automatizada + +## Retenção de objetos para AI/ML + +- Integridade +- Conformidade +- Sensibilidade temporal +- Consistência + +### Políticas de retenção + +- Consistência de modelos/datasets +- Evitar eliminações/alterações não autorizadas +- Histórico de versões + +#### Governação de dados + +- Framework de governação +- Conformidade +- Reprodutibilidade +- Linhagem + +## Proteção de dados para AI + +- EC e replicação +- Encriptação +- IAM granular +- Integridade, disponibilidade e confidencialidade fim‑a‑fim + +Com a integração SQL Server 2022 + RustFS, construa uma plataforma moderna, segura e performante para workloads de dados tradicionais e AI/ML. diff --git a/docs/pt/features/tanzu/images/sec1-1.png b/docs/pt/features/tanzu/images/sec1-1.png new file mode 100644 index 0000000..07116ed Binary files /dev/null and b/docs/pt/features/tanzu/images/sec1-1.png differ diff --git a/docs/pt/features/tanzu/index.md b/docs/pt/features/tanzu/index.md new file mode 100644 index 0000000..9248719 --- /dev/null +++ b/docs/pt/features/tanzu/index.md @@ -0,0 +1,55 @@ +# RustFS para VMware Tanzu Kubernetes Platform + +## Três razões para executar RustFS no VMware Tanzu + +- Camada de armazenamento consistente em cenários híbridos/multicloud +- Produto cloud‑native de alto desempenho no Kubernetes (público/privado/edge) +- Controle da pilha no Tanzu, evitando lock‑in + +O VMware Tanzu é uma plataforma Kubernetes empresarial com operações automatizadas de pilha completa para gerir implantações híbridas, multicloud e edge. + +O RustFS integra‑se nativamente ao Tanzu para operar armazenamento de objetos multi‑inquilino em grande escala, com toolchain do ecossistema Tanzu. + +![Arquitetura RustFS](images/sec1-1.png) + +Sendo Kubernetes‑native e compatível com S3 desde a origem, o RustFS oferece armazenamento de objetos consistente, performante e escalável. Diferente do S3, escala entre infraestruturas híbridas/multicloud sem lock‑in. + +## Integração nativa do RustFS Operator com Tanzu + +### Visão geral + +- Classes de armazenamento e tiering +- Load balancer externo +- Gestão de chaves (KMS) +- Gestão de identidade +- Gestão de certificados +- Monitorização e alertas +- Logging e auditoria + +## Classes de armazenamento e tiering + +Tiering entre NVMe/HDD/cloud com namespace único e políticas. + +## Load balancer externo + +Ingress compatível com Kubernetes (inclui NGINX). Exponha tenants com anotações. + +## Gestão de chaves (KMS) + +Encriptação por padrão; AES‑256‑GCM/ChaCha20‑Poly1305; SSE‑KMS/SSE‑S3/SSE‑C; KMS inicializa KES por tenant. + +## Gestão de identidade + +SSO via OpenID Connect/LDAP (Keycloak, Okta/Auth0, Google, AD, OpenLDAP). IAM estilo AWS (utilizadores/grupos/papéis/políticas/STS). + +## Gestão de certificados + +TLS fim‑a‑fim; integração com gestor de certificados. + +## Monitorização e alertas + +Métricas Prometheus; Grafana/monitoring; alertas. + +## Logging e auditoria + +Auditoria de operações e erros; exportação para Elastic Stack/terceiros. diff --git a/docs/pt/features/veeam/images/backup-performance.png b/docs/pt/features/veeam/images/backup-performance.png new file mode 100644 index 0000000..6e61219 Binary files /dev/null and b/docs/pt/features/veeam/images/backup-performance.png differ diff --git a/docs/pt/features/veeam/images/backup-restore.png b/docs/pt/features/veeam/images/backup-restore.png new file mode 100644 index 0000000..ad78f90 Binary files /dev/null and b/docs/pt/features/veeam/images/backup-restore.png differ diff --git a/docs/pt/features/veeam/images/hardware-agnostic.png b/docs/pt/features/veeam/images/hardware-agnostic.png new file mode 100644 index 0000000..136cdc4 Binary files /dev/null and b/docs/pt/features/veeam/images/hardware-agnostic.png differ diff --git a/docs/pt/features/veeam/images/inline-consistency.png b/docs/pt/features/veeam/images/inline-consistency.png new file mode 100644 index 0000000..ebab4db Binary files /dev/null and b/docs/pt/features/veeam/images/inline-consistency.png differ diff --git a/docs/pt/features/veeam/images/metadata-advantage.png b/docs/pt/features/veeam/images/metadata-advantage.png new file mode 100644 index 0000000..baf077e Binary files /dev/null and b/docs/pt/features/veeam/images/metadata-advantage.png differ diff --git a/docs/pt/features/veeam/images/veeam-logo.png b/docs/pt/features/veeam/images/veeam-logo.png new file mode 100644 index 0000000..7202b3e Binary files /dev/null and b/docs/pt/features/veeam/images/veeam-logo.png differ diff --git a/docs/pt/features/veeam/index.md b/docs/pt/features/veeam/index.md new file mode 100644 index 0000000..ddde915 --- /dev/null +++ b/docs/pt/features/veeam/index.md @@ -0,0 +1,55 @@ +# Armazenamento de objetos de alto desempenho para Veeam Backup & Replication + +![Veeam Logo](./images/veeam-logo.png) + +Escale sua instância v12 e aumente capacidade e desempenho do Veeam com o RustFS. + +## RustFS + Veeam: armazenamento de objetos privado de alto desempenho como endpoint S3 + +O Veeam Backup & Replication oferece soluções de backup otimizadas e definidas por software. Em conjunto, adicionamos armazenamento de objetos de alto desempenho como endpoint, desacoplando computação e armazenamento no ambiente de backup, com excelente performance, escalabilidade e economia. Um único cluster RustFS pode servir como endpoint Veeam para VMs, Oracle, SAP e MS Office. + +## Principais cenários + +### 🖥️ Backups Veeam para VMware ESXi com RustFS + +Backups de infraestrutura virtual diretamente em armazenamento de objetos, com flexibilidade de capacidade praticamente ilimitada e controlo de custo/segurança. + +### 📧 Backups Veeam para Microsoft 365 com RustFS + +Backups do Microsoft 365 para armazenamento de objetos, com elasticidade de capacidade e políticas de proteção de dados. + +### 💼 Backups Veeam para SAP HANA com RustFS + +Com RustFS, os backups Veeam para SAP HANA ganham em desempenho e segurança. + +### 🗄️ Backups Veeam para Oracle com RustFS + +Workloads Oracle exigem desempenho, resiliência e segurança. Otimize estes backups críticos com armazenamento de objetos RustFS. + +--- + +## Veeam e RustFS: parceria natural + +Ambos entregam software de classe mundial. De VMs ao Microsoft 365, a performance em escala é a métrica chave. O RustFS provê uma solução de armazenamento de objetos altamente escalável e performante, ideal para clientes Veeam. + +## Vantagens + +### ⚡ Backup rápido é uma coisa; restore rápido é outra + +Backups e restores precisam ser rápidos. RustFS com Veeam pode ler/escrever a mais de 160 GiB/s em um cluster de 32 nós, viabilizando velocidades de backup/restore antes consideradas impraticáveis. + +### 🗃️ Metadados a favor + +Com tabelas externas, é possível usar todo o poder do SQL Server sem mover dados. O RustFS grava metadados de forma atômica com os objetos, dispensando bases externas (como Cassandra) em muitos casos. Isso elimina penalidades comuns de pequenos objetos. O RustFS atende às recomendações de tamanho de objeto do Veeam, ajudando em deleções rápidas e deduplicação. + +### 🔒 Inline e estritamente consistente + +Os dados no RustFS são sempre legíveis e consistentes: todo I/O é commitado em sincronia com EC inline, verificação de bitrot e encriptação. O serviço S3 é resiliente a interrupções e reinícios sob carga. Não há caches/staging assíncronos – garantindo sucesso das operações de backup. + +### 🔧 Agnóstico a hardware + +Assim como o Veeam, o RustFS é definido por software e agnóstico a hardware, gerando economia e flexibilidade no desenho de soluções de backup. + +### 🚀 RustFS + Veeam: backup e restore a partir de armazenamento de objetos + +A combinação entrega as vantagens do SDS, velocidade de backup/restore e resiliência de um armazenamento de objetos que grava metadados de forma atômica. diff --git a/docs/pt/features/versioning/images/architecture.png b/docs/pt/features/versioning/images/architecture.png new file mode 100644 index 0000000..e728e41 Binary files /dev/null and b/docs/pt/features/versioning/images/architecture.png differ diff --git a/docs/pt/features/versioning/images/bucket-states.png b/docs/pt/features/versioning/images/bucket-states.png new file mode 100644 index 0000000..82e4b19 Binary files /dev/null and b/docs/pt/features/versioning/images/bucket-states.png differ diff --git a/docs/pt/features/versioning/images/versioning-overview.png b/docs/pt/features/versioning/images/versioning-overview.png new file mode 100644 index 0000000..88be5c8 Binary files /dev/null and b/docs/pt/features/versioning/images/versioning-overview.png differ diff --git a/docs/pt/features/versioning/index.md b/docs/pt/features/versioning/index.md new file mode 100644 index 0000000..8344999 --- /dev/null +++ b/docs/pt/features/versioning/index.md @@ -0,0 +1,63 @@ +# Versionamento de buckets e objetos + +## Compatibilidade com versionamento AWS S3 + +Comparado a SAN/NAS, o versionamento a nível de objeto é um avanço. Além de proteger dados, é base para bloqueio de objetos, imutabilidade, tiering e gestão do ciclo de vida. + +No RustFS, cada objeto é versionado de forma independente conforme a semântica S3. Cada versão recebe um ID único; aplicações podem referenciar um version ID para obter um snapshot temporal. + +O versionamento permite manter múltiplas variantes do mesmo objeto no bucket, com mecanismos para salvar, recuperar e restaurar cada versão – eliminando a necessidade de snapshots. Protege contra falhas diversas, incluindo erros humanos/aplicativos. + +Ative no nível do bucket. Após ativar, o RustFS cria automaticamente IDs únicos por versão e o mesmo objeto pode ter várias versões. + +Um benefício chave é impedir sobrescrita/exclusão acidental, usando delete markers. Ao “apagar” um objeto versionado, cria‑se um delete marker como versão atual (o GET retorna 404). Para restaurar, remova o delete marker. + +De forma similar, ao sobrescrever um objeto versionado, cria‑se nova versão como atual; versões antigas podem ser restauradas quando necessário. + +## Três estados de versionamento por bucket + +![Estados do bucket](./images/bucket-states.png) + +Uma vez ativado o versionamento, não é possível desfazer – apenas pausar. É um setting global do bucket. + +Com permissões adequadas, é possível pausar para interromper a criação de novas versões. Tal como a ativação, a pausa é aplicada no nível do bucket. + +O versionamento pode ser aplicado via Console do RustFS, cliente (mc), SDKs ou linha de comando. + +Versionamento é a forma mais simples de proteger contra operações acidentais. Contudo, mais versões aumentam o tamanho do bucket e dependências entre objetos; mitigue com regras de ciclo de vida. + +## Benefícios principais + +> Além de proteção de dados, o versionamento do RustFS fundamenta várias capacidades‑chave + +### Destaques + +- ✅ Replicação de buckets (ativo‑ativo, ativo‑passivo) +- ✅ mc undo – reverter PUT/DELETE com um comando +- ✅ Bloqueio de objetos +- ✅ Proteção tipo CDP sem overhead de snapshots/replicação completa +- ✅ mc rewind – visualizar bucket/objeto em qualquer ponto após ativação + +## Arquitetura + +![Arquitetura](./images/architecture.png) + +### Requisitos do sistema + +> Versionamento requer EC e ao menos quatro discos. + +### Estados de versionamento + +O RustFS suporta três estados distintos de versionamento de bucket: + +1. 🔴 Desativado – estado padrão +2. 🟢 Ativado – ID único por versão, versionamento completo +3. 🟡 Pausado – não cria novas versões, mantém as existentes + +### Recursos‑chave + +- 🆔 ID único por versão +- 🔄 Recuperação temporal por version ID +- 🛡️ Proteção contra eliminação acidental (delete markers) +- 📊 Gestão do ciclo de vida para controlar quantidade/custos de versões +- 🔐 Controlo de permissões refinado diff --git a/docs/pt/features/video/images/item-1.png b/docs/pt/features/video/images/item-1.png new file mode 100644 index 0000000..64cd875 Binary files /dev/null and b/docs/pt/features/video/images/item-1.png differ diff --git a/docs/pt/features/video/images/item-2.png b/docs/pt/features/video/images/item-2.png new file mode 100644 index 0000000..6cbe1d6 Binary files /dev/null and b/docs/pt/features/video/images/item-2.png differ diff --git a/docs/pt/features/video/images/item-3.png b/docs/pt/features/video/images/item-3.png new file mode 100644 index 0000000..9443a6a Binary files /dev/null and b/docs/pt/features/video/images/item-3.png differ diff --git a/docs/pt/features/video/images/item-4.png b/docs/pt/features/video/images/item-4.png new file mode 100644 index 0000000..3196823 Binary files /dev/null and b/docs/pt/features/video/images/item-4.png differ diff --git a/docs/pt/features/video/images/params.png b/docs/pt/features/video/images/params.png new file mode 100644 index 0000000..0f391d8 Binary files /dev/null and b/docs/pt/features/video/images/params.png differ diff --git a/docs/pt/features/video/images/solution.png b/docs/pt/features/video/images/solution.png new file mode 100644 index 0000000..3807049 Binary files /dev/null and b/docs/pt/features/video/images/solution.png differ diff --git a/docs/pt/features/video/index.md b/docs/pt/features/video/index.md new file mode 100644 index 0000000..47dad31 --- /dev/null +++ b/docs/pt/features/video/index.md @@ -0,0 +1,103 @@ +# Solução de redução de custos para armazenamento de vídeo + +Reduza significativamente o custo de armazenamento de vídeo com armazenamento de objetos e arquitetura híbrida/multicloud. + +## Desafios centrais do armazenamento de vídeo + +### Limitações de abordagens tradicionais + +- Arquiteturas lineares degradam I/O com crescimento de capacidade +- Vídeo bruto consome espaço; dados frios ocupam camadas de alto desempenho +- Replicação simples + backups periódicos +- Expansão exige janelas de manutenção; falta de ferramentas de gestão inteligentes + +### Impacto no negócio + +- Atrasos ao recuperar frames críticos afetam resposta a incidentes +- Crescimento acelerado de custo; grande parte do storage é acesso esporádico +- Risco de recuperação lenta após falhas +- Custo operacional por TB elevado, disponibilidade inferior ao desejado + +## Cinco pilares de otimização de custo + +### Otimização de armazenamento + +- Compressão/encodes eficientes adequados ao caso +- Tiering automático: dados frios migram para camadas de custo reduzido +- Escala elástica para níveis de capacidade elevados + +### Acesso eficiente + +- Caching/edge para acelerar acesso distribuído +- Suporte a ingest concorrente +- Pré‑carregamento para conteúdos de alto acesso + +### Proteção de dados + +- Redundância e resiliência geográfica +- Trilha de auditoria e integridade dos conteúdos +- Versionamento e restauração por ponto‑no‑tempo + +### Integração simplificada + +- Compatível com protocolos comuns de vídeo/ingestão +- SDK/API/REST para integração +- Ferramentas de migração de dados legados + +### Observabilidade e otimização + +- Monitorização de saúde/custos/hotspots +- Projeção de capacidade e alertas +- Recomendações de otimização contínuas + +## Arquiteturas de referência + +Os fluxos de vídeo podem chegar à nuvem de três maneiras. + +### Armazenamento híbrido em camadas + +Cenário: campus/parques urbanos com grande nº de câmeras. + +- Tiering: quente em SSD on‑prem; full replica na nuvem +- Otimização de custos com camadas frias +- Alta disponibilidade ativa‑ativa entre on‑prem e nuvem + +### Gravação direta na nuvem + +Cenário: retalho, condomínios, residências. + +- Provisionamento simplificado +- Gestão inteligente de eventos/clipes +- Armazenamento gerido, com durabilidade elevada + +### Servidor de trânsito/edge + +Cenário: educação, empresas multi‑região. + +- Pré‑processamento na borda (redução de tráfego) +- Roteamento adaptativo +- Arquivo em camadas (curto prazo quente, longo prazo frio) + +![Arquitetura de solução](./images/solution.png) + +## Por que RustFS + +### Custo sob controle + +- Escala elástica; dados frios em camadas económicas + +### Performance + +- Nós de edge e caching para acesso mais rápido + +### Encriptação na ingestão + +- Proteção dos conteúdos em trânsito e at‑rest + +### Versionamento + +- Restauração de conteúdos por histórico + +## Comparativo técnico + +![Comparativo técnico](./images/params.png) diff --git a/docs/pt/features/worm/index.md b/docs/pt/features/worm/index.md new file mode 100644 index 0000000..28e0cd3 --- /dev/null +++ b/docs/pt/features/worm/index.md @@ -0,0 +1,41 @@ +# Imutabilidade de objetos no RustFS + +## RustFS e S3 API — concebido para multicloud + +O RustFS adota o S3 como padrão desde o início. Como um dos primeiros a suportar S3 API (V2 e V4) e focado em S3, a comunidade assegura elevada compatibilidade. O S3 é o padrão de facto na nuvem; para interoperar em ambientes públicos/privados/híbridos/edge, a compatibilidade de API é essencial. + +## Retenção de objetos + +Políticas de retenção garantem proteção WORM por um período. A retenção pode ser definida por versão de objeto (explícita) ou por padrão no bucket. A configuração padrão do bucket aplica‑se a objetos criados depois (não retroativa). + +Com o padrão do bucket, define‑se a duração em dias/anos para proteger cada nova versão colocada no bucket. Objetos novos herdam a duração. + +Pode‑se definir retenção explícita por versão, com uma “data de expiração de retenção” armazenada nos metadados. Até expirar, a versão fica protegida. + +Após expirar, a versão pode ser eliminada, salvo se houver legal hold. + +A retenção explícita sobrepõe o padrão do bucket. + +A duração pode ser estendida emitindo nova solicitação de bloqueio. + +Existem dois modos de retenção: + +## Modo de governança + +Evita que utilizadores comuns apaguem objetos. Para determinados utilizadores com necessidade de alterar retenções ou eliminar objetos, conceda permissões específicas, como `s3:BypassGovernanceRetention` e `DeleteObject`. + +## Modo de conformidade + +Mais restritivo: não pode ser removido durante o período de retenção. Nem mesmo o root pode eliminar a versão nesse período. + +## Legal hold + +Oferece proteção WORM equivalente à retenção, porém sem data de expiração. É indefinido e só pode ser removido por utilizadores autorizados. + +Quando há retenção ou legal hold, o versionamento permanece. Operações de cópia entre buckets não propagam automaticamente retenção/legal hold do source para o destino. + +## Conformidade do RustFS com Cohasset + +A referência para bloqueio/imutabilidade/retenção é a avaliação da Cohasset Associates. O RustFS obteve avaliação positiva relativamente às exigências de SEC 17a‑4(f), FINRA 4511 e CFTC 1.31, incluindo duração, formato, qualidade, disponibilidade e responsabilização. + +O relatório da Cohasset pode ser obtido integralmente e partilhado com reguladores ao armazenar dados no RustFS. Nele constam detalhes de configuração e a lógica de suporte ao bloqueio de objetos. diff --git a/docs/pt/guide/access-token.md b/docs/pt/guide/access-token.md new file mode 100644 index 0000000..17d5291 --- /dev/null +++ b/docs/pt/guide/access-token.md @@ -0,0 +1,31 @@ +--- +title: "Gestão de chaves de acesso do RustFS" +description: "Criar, usar e eliminar chaves de acesso no RustFS" +--- + +# Chaves de acesso + +As chaves de acesso do RustFS são credenciais essenciais para autenticar identidades e autorizar operações. São especialmente úteis em cenários de API e SDK. Esta secção explica como criar e eliminar chaves de acesso. + +Pré‑requisitos: + +- Uma instância RustFS disponível. Consulte o [guia de instalação](../installation/index.md). + +## Criar uma chave de acesso + +1. Inicie sessão na consola UI do RustFS. +1. No menu lateral, selecione "Chaves de acesso". +1. Na página de chaves, no canto superior direito, clique em "Adicionar chave de acesso". +1. Introduza "validade, nome e descrição" e clique em "Submeter". +1. (Opcional, recomendado) Na página da chave, escolha "Copiar" ou "Exportar" para guardar a chave em segurança. + +![access key list page](images/access_token_creation.png) + +## Eliminar uma chave de acesso + +1. Inicie sessão na consola UI do RustFS. +1. No menu lateral, selecione "Chaves de acesso". +1. Selecione a chave que pretende eliminar. +1. Clique em "Eliminar" na linha da chave ou em "Eliminar selecionados" no canto superior direito. + +![access key deletion](images/access_token_deletion.png) \ No newline at end of file diff --git a/docs/pt/guide/bucket/bucket-create-and-delete.md b/docs/pt/guide/bucket/bucket-create-and-delete.md new file mode 100644 index 0000000..8adfa3e --- /dev/null +++ b/docs/pt/guide/bucket/bucket-create-and-delete.md @@ -0,0 +1,96 @@ +--- +title: "Gestão de buckets do RustFS" +description: "Criar e eliminar buckets no RustFS" +--- + +# Buckets do RustFS + +Um bucket é o contentor lógico básico para organizar e gerir dados no RustFS. Cada bucket tem um nome único e pode conter vários objetos. Pode gerir buckets através da UI do RustFS, do `mc` (MinIO Client) ou via API (criar, eliminar, carregar/transferir dados, etc.). + +## Criar um bucket + +Pré‑requisitos: + +- Uma instância RustFS disponível (../../installation/index.md) + +## Criar na UI do RustFS + +1. Inicie sessão na consola UI do RustFS. +1. Na página inicial, no canto superior esquerdo, clique em "Criar bucket". +1. Introduza o nome do bucket e clique em "Criar". + +![bucket creation](images/bucket-creation-by-ui.png) + +### Criar com `mc` + +> Consulte o guia do [`mc`](../mc.md) para instalação e configuração. + +``` +# creat rustfs bucket +mc mb rustfs/bucket-creation-by-mc +Bucket created successfully `rustfs/bucket-creation-by-mc`. + +# confirm bucket creation +mc ls rustfs/bucket-creation-by-mc +``` + +### Criar via API + +``` +PUT /{bucketName} HTTP/1.1 +``` + +Exemplo de pedido: + +``` +curl --location --request PUT 'http://12.34.56.78:9000/bucket-creation-by-api' \ +--header 'X-Amz-Content-Sha256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' \ +--header 'X-Amz-Date: 20250801T023519Z' \ +--header 'Authorization: AWS4-HMAC-SHA256 Credential=H4xcBZKQfvJjEnk3zp1N/20250801/cn-east-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=c2fb2ba5199a30ebcfa9976d0f35000ba274da3701327957e84ea0f3920288f2' +``` + +Pode confirmar na UI que o bucket `bucket-creation-by-api` foi criado com sucesso. + +## Eliminar um bucket + +Atenção: eliminar um bucket pode causar erros em aplicações que o utilizem. Faça cópia de segurança dos dados e confirme que já não é necessário. + +### Eliminar na UI do RustFS + +1. Inicie sessão na consola UI do RustFS. +1. Na página inicial, selecione o bucket a eliminar. +1. Clique em "Eliminar" no extremo direito. +1. No diálogo apresentado, clique em "Confirmar". + +![bucket deletion](images/bucket-deletion-on-ui.png) + +### Eliminar com `mc` + +> Consulte o guia do [`mc`](../mc.md). + +``` +# delete bucket +mc rb rustfs/bucket-creation-by-mc +Removed `rustfs/bucket-creation-by-mc` successfully. + +# confirm bucket deletion +mc ls rustfs/bucket-creation-by-mc +mc: Unable to list folder. Bucket `bucket-creation-by-mc` does not exist. +``` + +### Eliminar via API + +``` +DELETE /{bucketName} HTTP/1.1 +``` + +Exemplo de pedido: + +``` +curl --location --request DELETE 'http://12.34.56.78:9000/bucket-creation-by-api' \ +--header 'X-Amz-Content-Sha256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' \ +--header 'X-Amz-Date: 20250801T024406Z' \ +--header 'Authorization: AWS4-HMAC-SHA256 Credential=H4xcBZKQfvJjEnk3zp1N/20250801/cn-east-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=d0f6addf09fffd7eef75191e9d3209bb7188e6b004e9707238fc60ad7033edae' +``` + +Na UI do RustFS, pode confirmar que o bucket `bucket-creation-by-api` foi eliminado. \ No newline at end of file diff --git a/docs/pt/guide/bucket/images/bucket-creation-by-ui.png b/docs/pt/guide/bucket/images/bucket-creation-by-ui.png new file mode 100644 index 0000000..4eb368f Binary files /dev/null and b/docs/pt/guide/bucket/images/bucket-creation-by-ui.png differ diff --git a/docs/pt/guide/bucket/images/bucket-deletion-on-ui.png b/docs/pt/guide/bucket/images/bucket-deletion-on-ui.png new file mode 100644 index 0000000..099655a Binary files /dev/null and b/docs/pt/guide/bucket/images/bucket-deletion-on-ui.png differ diff --git a/docs/pt/guide/bucket/images/delete_file_from_ui.png b/docs/pt/guide/bucket/images/delete_file_from_ui.png new file mode 100644 index 0000000..24ab021 Binary files /dev/null and b/docs/pt/guide/bucket/images/delete_file_from_ui.png differ diff --git a/docs/pt/guide/bucket/images/object_details_info.png b/docs/pt/guide/bucket/images/object_details_info.png new file mode 100644 index 0000000..2524e14 Binary files /dev/null and b/docs/pt/guide/bucket/images/object_details_info.png differ diff --git a/docs/pt/guide/bucket/images/upload_file_from_ui.png b/docs/pt/guide/bucket/images/upload_file_from_ui.png new file mode 100644 index 0000000..0ddd76a Binary files /dev/null and b/docs/pt/guide/bucket/images/upload_file_from_ui.png differ diff --git a/docs/pt/guide/bucket/object-upload-and-delete.md b/docs/pt/guide/bucket/object-upload-and-delete.md new file mode 100644 index 0000000..d1a5171 --- /dev/null +++ b/docs/pt/guide/bucket/object-upload-and-delete.md @@ -0,0 +1,103 @@ +--- +title: "Gestão de objetos do RustFS" +description: "Carregar e eliminar objetos" +--- + +# Objetos do RustFS + +Um objeto é a unidade básica de armazenamento no RustFS, contendo dados, metadados e um identificador único (Object Key). Esta secção demonstra a gestão de objetos através do exemplo de carregamento e eliminação de ficheiros. + +> Para conceitos relacionados com objetos, consulte [Conceitos](../../concepts/glossary.md). + +## Criar um objeto + +Pré‑requisitos: + +- Uma instância RustFS disponível (../../installation/index.md) + +Crie primeiro um [bucket](bucket-create-and-delete.md) e, em seguida, carregue um ficheiro para esse bucket para criar um objeto. Pode fazê‑lo pela UI, `mc` ou API. + +### Carregar pela UI do RustFS + +1. Inicie sessão na consola UI do RustFS. +1. Selecione o bucket de destino. +1. No canto superior direito da página do bucket, escolha "Nova pasta", "Novo ficheiro" ou "Carregar ficheiro/pasta". +1. Para carregamento local, clique em "Carregar ficheiro/pasta", selecione os itens e clique em "Iniciar carregamento". + +![object creation from ui](images/upload_file_from_ui.png) + +Após o carregamento, clique no objeto para ver os detalhes. + +![object details info](images/object_details_info.png) + +### Carregar com `mc` + +> Consulte o guia do [`mc`](../mc.md). + +``` +# upload file +mc cp 1.txt rustfs/bucket-creation-by-mc +/tmp/1.txt: 13 B / 13 B ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 61 B/s 0s% + +# confirm file uploaded +mc ls rustfs/bucket-creation-by-mc +[2025-08-01 10:01:08 CST] 13B 1.txt +``` + +### Carregar via API + +``` +PUT /{bucketName}/{objectName} HTTP/1.1 +``` + +Exemplo de pedido: + +``` +curl --location --request PUT 'http://12.34.56.78:9000/bucket-creation-by-api/password.txt' \ +--header 'Content-Type: text/plain' \ +--header 'X-Amz-Content-Sha256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' \ +--header 'X-Amz-Date: 20250801T024840Z' \ +--header 'Authorization: AWS4-HMAC-SHA256 Credential=H4xcBZKQfvJjEnk3zp1N/20250801/cn-east-1/s3/aws4_request, SignedHeaders=content-length;content-type;host;x-amz-content-sha256;x-amz-date, Signature=b7d8dc29ee34dfdf1f3e9e8e069892a8936f478586e7a2c90cf34f5b86d3a2dc' \ +--data-binary '@/path/to/password.txt' +``` + +## Eliminar um objeto + +A eliminação pode ser feita pela UI, `mc` ou API. Por exemplo, elimine o ficheiro criado acima. + +## Eliminar pela UI do RustFS + +1. Inicie sessão na consola UI do RustFS. +1. Selecione o bucket que contém o ficheiro. +1. Selecione o ficheiro a eliminar. +1. Clique em "Eliminar selecionados" e confirme. + +![object deletion from ui](images/delete_file_from_ui.png) + +### Eliminar com `mc` + +``` +# delete file +mc rm rustfs/bucket-creation-by-mc/1.txt +Removed `rustfs/bucket-creation-by-mc/1.txt`. + +# confirm deletion +mc ls rustfs/bucket-creation-by-mc/1.txt +``` + +### Eliminar via API + +``` +DELETE /{bucketName}/{objectName} HTTP/1.1 +``` + +Exemplo de pedido: + +``` +curl --location --request DELETE 'http://12.34.56.78:9000/bucket-creation-by-api/password.txt' \ +--header 'Content-Type: text/plain' \ +--header 'X-Amz-Content-Sha256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' \ +--header 'X-Amz-Date: 20250801T030822Z' \ +--header 'Authorization: AWS4-HMAC-SHA256 Credential=H4xcBZKQfvJjEnk3zp1N/20250801/cn-east-1/s3/aws4_request, SignedHeaders=content-length;content-type;host;x-amz-content-sha256;x-amz-date, Signature=1ee63bb0b699598602b2fdbd013e355a57bcb9991307a8ad41f6512e8afebf3a' \ +--data-binary '@/Users/jhma/Desktop/password.txt' +``` \ No newline at end of file diff --git a/docs/pt/guide/images/access_token_creation.png b/docs/pt/guide/images/access_token_creation.png new file mode 100644 index 0000000..fbc3ce1 Binary files /dev/null and b/docs/pt/guide/images/access_token_creation.png differ diff --git a/docs/pt/guide/images/access_token_deletion.png b/docs/pt/guide/images/access_token_deletion.png new file mode 100644 index 0000000..1575270 Binary files /dev/null and b/docs/pt/guide/images/access_token_deletion.png differ diff --git a/docs/pt/guide/mc.md b/docs/pt/guide/mc.md new file mode 100644 index 0000000..aa544ba --- /dev/null +++ b/docs/pt/guide/mc.md @@ -0,0 +1,104 @@ +--- +title: "Gerir objetos do RustFS com MinIO Client" +description: "Utilizar o MinIO Client para gerir objetos no RustFS" +--- + +# MinIO Client (`mc`) + +O MinIO Client (`mc`) é a ferramenta oficial de linha de comando do MinIO para gerir serviços de armazenamento de objetos. Compatível com S3, o `mc` também pode gerir objetos do RustFS. + +Pré‑requisitos: + +- Uma instância do RustFS (../../pt/installation/index.md) +- `mc` instalado +- Uma [chave de acesso](access-token.md) + +## Operações no RustFS com `mc` + +Comece por definir um alias para o RustFS com `mc alias`: + +``` +mc alias set rustfs http://12.34.56.78:9000 ACCESS_KEY SECRET_KEY +``` + +Resposta: + +``` +Added `rustfs` successfully. +``` + +Depois utilize o alias `rustfs` para criar/eliminar buckets e carregar/transferir ficheiros. + +### Listar buckets + +``` +mc ls rustfs +``` + +Resposta: + +``` +[2025-08-01 10:46:24 CST] 0B bucket-creation-by-api/ +[2025-07-29 09:15:35 CST] 0B rustfs-demo/ +[2025-08-03 09:44:45 CST] 0B bucket-creation-by-ui/ +``` + +### Criar bucket + +``` +mc mb rustfs/bucket-creation-by-mc +``` + +Resposta: + +``` +Bucket created successfully `rustfs/bucket-creation-by-mc`. +``` + +### Eliminar bucket + +``` +mc rb rustfs/bucket-creation-by-mc +``` + +Resposta: + +``` +Removed `rustfs/bucket-creation-by-mc` successfully. +``` + +### Carregar ficheiro + +``` +mc cp file_name rustfs/bucket-creation-by-mc +``` + +Resposta: + +``` +...path/to/file_name: 4 B / 4 B ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 12 B/s 0s% +``` + +### Eliminar ficheiro + +``` +mc rm rustfs/bucket-creation-by-mc/file_name +``` + +Resposta: + +``` +Removed `rustfs/bucket-creation-by-mc/1.txt`. +``` + +### Transferir ficheiro + +``` +mc get rustfs/bucket-creation-by-mc/file_name ./file_name +``` + +Resposta: + +``` +...eation-by-mc/file_name: 4 B / 4 B ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 18 B/s 0s% +``` \ No newline at end of file diff --git a/docs/pt/guide/mcp.md b/docs/pt/guide/mcp.md new file mode 100644 index 0000000..9104a78 --- /dev/null +++ b/docs/pt/guide/mcp.md @@ -0,0 +1,178 @@ +--- +title: "RustFS MCP" +description: "Guia de utilização do RustFS MCP" +--- + +# RustFS MCP + +**O servidor RustFS MCP** é um servidor [Model Context Protocol (MCP)](https://spec.modelcontextprotocol.org) de alto desempenho que fornece acesso transparente a operações de armazenamento de objetos compatível com S3 para ferramentas de IA/LLM. Escrito em Rust para máxima performance e segurança, permite que assistentes como o Claude Desktop interajam com storage em nuvem via protocolo padronizado. + +### O que é MCP? + +O Model Context Protocol é um padrão aberto para conexões seguras e controladas entre aplicações de IA e sistemas externos. Este servidor atua como ponte entre ferramentas de IA e serviços S3‑compatíveis, oferecendo acesso estruturado a operações de ficheiros com segurança e observabilidade. + +## ✨ Funcionalidades + +### Operações S3 suportadas + +- Listar buckets: lista todos os buckets acessíveis +- Listar objetos: navegação com filtro opcional por prefixo +- Upload de ficheiros: upload local com deteção automática de MIME e cache control +- Obter objeto: leitura ou download de objetos do S3 + +## 🔧 Instalação + +### Pré‑requisitos + +- Rust 1.88+ (para compilar a partir da fonte) +- Credenciais AWS configuradas (variáveis de ambiente, AWS CLI ou IAM) +- Acesso a serviço S3‑compatível + +### Compilar a partir da fonte + +```bash +# Clonar repositório +git clone https://github.com/rustfs/rustfs.git +cd rustfs + +# Compilar o servidor MCP +cargo build --release -p rustfs-mcp + +# Binário disponível em +./target/release/rustfs-mcp +``` + +## ⚙️ Configuração + +### Variáveis de ambiente + +```bash +# Credenciais AWS (obrigatórias) +export AWS_ACCESS_KEY_ID=SEU_ACCESS_KEY +export AWS_SECRET_ACCESS_KEY=SEU_SECRET_KEY +export AWS_REGION=us-east-1 # opcional, padrão us-east-1 + +# Opcional: endpoint S3 personalizado (MinIO, etc.) +export AWS_ENDPOINT_URL=http://localhost:9000 + +# Nível de log (opcional) +export RUST_LOG=info +``` + +### Opções de linha de comando + +```bash +rustfs-mcp --help +``` + +Opções comuns: +- `--access-key-id`: Access Key para S3 +- `--secret-access-key`: Secret Key para S3 +- `--region`: região AWS (padrão: us-east-1) +- `--endpoint-url`: endpoint S3 personalizado (MinIO, LocalStack) +- `--log-level`: nível de log (padrão: rustfs_mcp_server=info) + +----- + +## 🚀 Utilização + +### Iniciar o servidor + +```bash +# Iniciar servidor MCP +rustfs-mcp + +# Com opções personalizadas +rustfs-mcp --log-level debug --region us-west-2 +``` + +### Integração com cliente de chat + +#### Opção 1: parâmetros de linha de comando + +```json +{ + "mcpServers": { + "rustfs-mcp": { + "command": "/path/to/rustfs-mcp", + "args": [ + "--access-key-id", "SEU_ACCESS_KEY", + "--secret-access-key", "SEU_SECRET_KEY", + "--region", "us-west-2", + "--log-level", "info" + ] + } + } +} +``` + +#### Opção 2: variáveis de ambiente + +```json +{ + "mcpServers": { + "rustfs-mcp": { + "command": "/path/to/rustfs-mcp", + "env": { + "AWS_ACCESS_KEY_ID": "SEU_ACCESS_KEY", + "AWS_SECRET_ACCESS_KEY": "SEU_SECRET_KEY", + "AWS_REGION": "us-east-1" + } + } + } +} +``` + +## 🛠️ Ferramentas disponíveis + +O servidor expõe as seguintes ferramentas para assistentes de IA: + +### `list_buckets` +Lista todos os buckets acessíveis com as credenciais configuradas. + +Parâmetros: nenhum + +### `list_objects` +Lista objetos num bucket S3, com filtro opcional por prefixo. + +Parâmetros: +- `bucket_name` (string): nome do bucket +- `prefix` (string, opcional): prefixo de filtro + +### `upload_file` +Carrega ficheiro local para S3, com deteção automática de MIME. + +Parâmetros: +- `local_file_path` (string): caminho local +- `bucket_name` (string): bucket de destino +- `object_key` (string): chave/rota destino +- `content_type` (string, opcional): content‑type (auto se ausente) +- `storage_class` (string, opcional): classe de armazenamento +- `cache_control` (string, opcional): cabeçalho de cache + +### `get_object` +Obtém objeto do S3 em dois modos: leitura direta do conteúdo ou download para ficheiro. + +Parâmetros: +- `bucket_name` (string): bucket origem +- `object_key` (string): chave do objeto +- `version_id` (string, opcional): versão (se versionado) +- `mode` (string, opcional): "read" (padrão) ou "download" +- `local_path` (string, opcional): caminho local (obrigatório se "download") +- `max_content_size` (número, opcional): limite para modo leitura (bytes, padrão 1MB) + +## Arquitetura + +O servidor MCP tem arquitetura modular: + +``` +rustfs-mcp/ +├── src/ +│ ├── main.rs # entrypoint, CLI e inicialização +│ ├── server.rs # implementação do servidor MCP e handlers +│ ├── s3_client.rs # wrapper S3 assíncrono +│ ├── config.rs # gestão de configuração e CLI +│ └── lib.rs # exports e API pública +└── Cargo.toml # dependências e metadados +``` + diff --git a/docs/pt/images/s2-1.png b/docs/pt/images/s2-1.png new file mode 100644 index 0000000..be0d98e Binary files /dev/null and b/docs/pt/images/s2-1.png differ diff --git a/docs/pt/index.md b/docs/pt/index.md new file mode 100644 index 0000000..6f89e15 --- /dev/null +++ b/docs/pt/index.md @@ -0,0 +1,10 @@ +--- +layout: page +sidebar: false +--- + + + + diff --git a/docs/pt/installation/checklists.md b/docs/pt/installation/checklists.md new file mode 100644 index 0000000..c2a2b79 --- /dev/null +++ b/docs/pt/installation/checklists.md @@ -0,0 +1,24 @@ +--- +title: "Listas de verificação" +description: "Checklist pré‑instalação do RustFS" +--- + +# Listas de verificação + +Os documentos abaixo reúnem as listas de verificação antes da instalação do RustFS, cobrindo o que deve estar pronto para um ambiente de produção e os principais pontos de atenção. + +Estas listas não substituem um plano específico para o seu ambiente e requisitos. Recomendamos obter orientação profissional baseada no seu cenário, indicadores e versão do RustFS utilizada. + +Para orientação profissional, contacte os nossos especialistas: 400-033-5363 ou e‑mail: hello@rustfs.com. + +Para suporte comunitário, abra uma issue no GitHub ou junte‑se ao nosso grupo de discussão. As respostas comunitárias não têm garantia de qualidade ou SLA. + +## Checklist + +1. [Checklist de hardware](./hard-checklists) + +2. [Checklist de segurança](./security-checklists) + +3. [Checklist de software](./software-checklists) + +4. [Checklist de rede](./network-checklists) diff --git a/docs/pt/installation/docker.md b/docs/pt/installation/docker.md new file mode 100644 index 0000000..86dbe66 --- /dev/null +++ b/docs/pt/installation/docker.md @@ -0,0 +1,197 @@ +--- +title: "Instalar RustFS com Docker" +description: "Implantação do RustFS via Docker" +--- + +# Instalar RustFS com Docker + +RustFS é um armazenamento de objetos distribuído de alto desempenho, 100% compatível com S3. No modo SNSD (single node, single disk), não há redundância adicional (sem EC), adequado para testes locais e cenários pequenos. +Este guia usa o binário oficial para Linux como base e empacota num contêiner via Dockerfile, configurando volumes e variáveis de ambiente para iniciar o serviço. + +--- + +## 1. Pré‑requisitos + +1) Requisitos da máquina + +- Docker ≥ 20.10 instalado e funcional +- Diretório local `/mnt/rustfs/data` (ou personalizado) para dados + +2) Rede e firewall + +- Garanta a abertura da porta 9000 (ou porta escolhida) + +3) Ficheiro de configuração + +- Em `/etc/rustfs/config.toml`, defina porta, credenciais admin, diretórios de dados, etc. + +--- + +## 2. Obter a imagem oficial + +Usando base Ubuntu, puxe a imagem oficial do RustFS: + +```bash +docker pull rustfs/rustfs +``` + +--- + +## 3. Configuração do ambiente + +Crie `/etc/rustfs/config.toml` no host. Exemplo de variáveis: + +```bash +RUSTFS_ACCESS_KEY=rustfsadmin +RUSTFS_SECRET_KEY=rustfsadmin +RUSTFS_VOLUMES="/data/rustfs{0...3}" +RUSTFS_ADDRESS=":9000" +#RUSTFS_SERVER_DOMAINS="play.rustfs.com:7000" +RUSTFS_CONSOLE_ENABLE=true +RUSTFS_OBS_ENDPOINT="" +RUSTFS_TLS_PATH="/opt/tls" +``` + +> Nota: veja a documentação de instalação Linux para defaults e formatos. + +--- + +## 4. Executar o contêiner RustFS + +Execução típica do SNSD com a imagem e configuração acima: + +```bash +docker run -d \ + --name rustfs_local \ + -p 9000:9000 \ + -v /mnt/rustfs/data:/data \ + rustfs/rustfs:latest \ + /data +``` + +Parâmetros: + +- `-p 9000:9000`: mapeia porta 9000 +- `-v /mnt/rustfs/data:/data`: monta volume de dados +- `--name rustfs_local`: nome do contêiner +- `-d`: em background + +--- + +### Exemplo com parâmetros completos + +```bash +docker run -d \ + --name rustfs_container \ + -p 9000:9000 \ + -v /mnt/rustfs/data:/data \ + -e RUSTFS_ACCESS_KEY=rustfsadmin \ + -e RUSTFS_SECRET_KEY=rustfsadmin \ + -e RUSTFS_CONSOLE_ENABLE=true \ + -e RUSTFS_SERVER_DOMAINS=example.com \ + rustfs/rustfs:latest \ + --address :9000 \ + --console-enable \ + --server-domains example.com \ + --access-key rustfsadmin \ + --secret-key rustfsadmin \ + /data +``` + +### Métodos de configuração + +1) Variáveis de ambiente (recomendado): +```bash +-e RUSTFS_ADDRESS=:9000 \ +-e RUSTFS_SERVER_DOMAINS=example.com \ +-e RUSTFS_ACCESS_KEY=rustfsadmin \ +-e RUSTFS_SECRET_KEY=rustfsadmin \ +-e RUSTFS_CONSOLE_ENABLE=true \ +``` + +2) Parâmetros de linha de comando: +``` +--address :9000 \ +--server-domains example.com \ +--access-key rustfsadmin \ +--secret-key rustfsadmin \ +--console-enable \ +``` + +3) Parâmetros obrigatórios: +- ``: no fim do comando, ex.: `/data` + +### Combinações comuns + +1) Configuração básica: +```bash +docker run -d \ + -p 9000:9000 \ + -v /mnt/data:/data \ + rustfs/rustfs:latest \ + /data +``` + +2) Ativar console: +```bash +docker run -d \ + -p 9000:9000 \ + -v /mnt/data:/data \ + -e RUSTFS_CONSOLE_ENABLE=true \ + rustfs/rustfs:latest \ + ./target/debug/rustfs \ + --console-enable \ + /data +``` + +3) Chaves de autenticação personalizadas: +```bash +docker run -d \ + -p 9000:9000 \ + -v /mnt/data:/data \ + -e RUSTFS_ACCESS_KEY=rustfsadmin \ + -e RUSTFS_SECRET_KEY=rustfsadmin \ + rustfs/rustfs:latest \ + ./target/debug/rustfs \ + --access-key rustfsadmin \ + --secret-key rustfsadmin \ + /data +``` + +### Notas + +1) Portas mapeadas corretamente (padrão 9000) +2) Volumes persistentes `-v /host:/container` +3) Pode misturar env + CLI, mas CLI tem prioridade +4) Para TLS, monte certificados: +```bash +-v /path/to/certs:/certs \ +-e RUSTFS_TLS_PATH=/certs \ +``` + +## 5. Verificação e acesso + +1) Estado e logs do contêiner: +```bash +docker logs rustfs_local +``` +Deve indicar sucesso e escuta na porta 9000. + +2) Testar S3 API (ex.: `mc`): +```bash +mc alias set rustfs http://localhost:9000 rustfsadmin ChangeMe123! +mc mb rustfs/mybucket +mc ls rustfs +``` +Se criar e listar buckets, a implantação está ok. + +## 6. Recomendações + +- Produção: multi‑nó, TLS, rotação de logs, backups periódicos +- Armazenamento: SSD/NVMe local, evitar NFS, acesso exclusivo ao diretório de dados + +--- + +## Resumo + +Este guia demonstrou como empacotar e executar o RustFS em modo SNSD via Docker para arranque rápido. Posteriormente, pode evoluir para MNMD em plataformas como Kubernetes/Swarm. diff --git a/docs/pt/installation/hard-checklists.md b/docs/pt/installation/hard-checklists.md new file mode 100644 index 0000000..e4045ea --- /dev/null +++ b/docs/pt/installation/hard-checklists.md @@ -0,0 +1,144 @@ +--- +title: "Guia de configuração de hardware para produção" +description: "RustFS é um armazenamento de objetos distribuído de alto desempenho desenvolvido em Rust. Este guia fornece recomendações de escolha e configuração de hardware para implantação em produção." +--- + +# Guia de configuração de hardware para produção + +## 1. Análise de planeamento + +Antes da produção, conduza 2–3 semanas de levantamento para avaliar: + +1. Escala de dados + - Volume inicial efetivo (em TiB) e proporção hot/cold + - Crescimento previsto em 24 meses (modelo de taxa trimestral) + - Número de objetos (média 128 KB–1 MB). Acima de 100 milhões exige otimizações + +2. Perfil de negócio + - Padrão de acesso: leitura intensiva (CDN) vs escrita intensiva (logs) + - Conformidade: retenção conforme regulação (ex.: 5 anos em finanças) + - Multissite: latência (<50 ms) e custo de banda entre regiões + +3. Arquitetura de armazenamento + - Planeamento de buckets por domínio de negócio (≤ 500 buckets ativos/cluster) + - DR: ativo‑ativo (recomendado) ou replicação assíncrona + +## 2. Matriz de configuração de hardware + +Configuração base sugerida por resultados de testes de stress: + +| Componente | Ambiente base | Padrão de produção | Alto desempenho | +|------------|----------------|--------------------|-----------------| +| Nº de nós | 4 | 8 | 16+ | +| Mídia | 4× NVMe SSD | 8× NVMe SSD | 12× NVMe SSD | +| Rede | Duplo 25GbE (LACP) | Duplo 100GbE | 200GbE | +| CPU | 2× Intel Silver 4310 (16c) | 2× AMD EPYC 7313 (32c) | 2× Intel Platinum 8461Y (48c) | +| Memória | 64 GB DDR4‑3200 ECC | 256 GB DDR5‑4800 ECC | 512 GB DDR5‑5600 ECC | +| Controlador | HBA 9500‑8i | HBA 9600‑16i | Duplo controlador redundante | + +Princípios críticos: +1) “Fazenda” homogénea: mesmo lote de hardware/firmware em todos os nós +2) Rede: leaf‑spine + rede de storage isolada + dupla uplink +3) Servidor 2U recomendado; ≥ 12 bays por nó (conforme discos reais) + +## 3. Otimização de caminho crítico + +### 1) Topologia de rede (prioridade máxima) +- Cálculo de banda: reserve 0,5 Gbps por TiB efetivo (ex.: 100 TiB ⇒ 50 Gbps dedicados) +- Latência: + - P99 entre nós ≤ 2 ms + - Entre racks ≤ 5 ms + +### 2) Subsistema de armazenamento +- Controlador: + - Read‑ahead ativo (≥ 256 MB) + - RAID desativado (modo HBA pass‑through) + - Verificar saúde de BBU regularmente +- SSD: + - 20% OP para durabilidade + - Atomic write se suportado + +### 3) Gestão de memória +- Proporções: + - Cache de metadados: 60% + - Buffers R/W: 30% + - Reserva do sistema: 10% + +## 4. Modelos de rede de referência + +### Relação banda vs discos +| Rede | Throughput teórico | Mídia | Nº máx. de discos | +|------|--------------------|-------|-------------------| +| 10GbE | 1.25 GB/s | HDD 7.2K (180 MB/s) | 8 | +| 25GbE | 3.125 GB/s | SATA SSD (550 MB/s) | 6 | +| 100GbE | 12.5 GB/s | NVMe Gen4 (7 GB/s) | 2 a full RW | + +Caso prático: plataforma de vídeo com 16 nós, cada um com: +- 8× 7.68 TB NVMe SSD +- Duas NICs 100GbE CX5 +- Throughput agregado 38 GB/s + +## 5. Calculadora de memória + +Algoritmo dinâmico por capacidade e padrão de acesso: + +```python +# Fórmula (GB) +def calc_memory(data_tb, access_pattern): + base = 32 + if access_pattern == "read_heavy": + return base + data_tb * 0.8 + elif access_pattern == "write_heavy": + return base + data_tb * 1.2 + else: # mixed + return base + data_tb * 1.0 +``` + +Tabela de referência: +| Escala | Leitura | Escrita | Misto | +|--------|---------|---------|-------| +| 10 TB | 40 GB | 44 GB | 42 GB | +| 100 TB | 112 GB | 152 GB | 132 GB | +| 500 TB | 432 GB | 632 GB | 532 GB | + +## 6. Normas de implantação de storage + +### 1) Seleção de mídia +| Métrica | HDD | SSD | NVMe (requisitos) | +|--------|-----|-----|-------------------| +| Latência | >50 ms | 1–10 ms | <1 ms | +| Throughput | < 500 MB/s | 500 MB–3 GB/s | > 3 GB/s | +| Casos | Arquivo | Hot cache | Análise em tempo real | + +### 2) Sistema de ficheiros +```bash +# Exemplo XFS +mkfs.xfs -f -L rustfs_disk1 -d su=256k,sw=10 /dev/sdb + +# Montagem recomendada +UUID=xxxx /mnt/disk1 xfs defaults,noatime,nodiratime,logbsize=256k 0 0 +``` + +## 7. Alta disponibilidade + +1) Energia +- Dual power feed +- PDUs em subestações distintas +- UPS (≥ 30 min) + +2) Arrefecimento +- Densidade ≤ 15 kW/rack +- Delta T in/out ≤ 8 °C + +3) Firmware +- Matriz de compatibilidade de hardware +- Versões de firmware unificadas + +> Sugestão: execute stress test de 72 h antes da produção, simulando: +> 1) Failover de nó +> 2) Partition de rede +> 3) Pico de escrita (até 120% do teórico) + +--- + +Este guia baseia‑se na versão recente do RustFS. Ajuste parâmetros conforme whitepapers dos fornecedores e considere auditoria de saúde de hardware trimestral com a equipa RustFS. \ No newline at end of file diff --git a/docs/pt/installation/hardware-selection.md b/docs/pt/installation/hardware-selection.md new file mode 100644 index 0000000..f7d7dc8 --- /dev/null +++ b/docs/pt/installation/hardware-selection.md @@ -0,0 +1,41 @@ +--- +title: "Seleção de hardware" +description: "Que hardware posso usar para executar o RustFS?" +--- + +# Seleção de hardware + +> O RustFS tem baixa exigência de memória e jitter estável. + +## Ambiente de testes + +> Para uso rápido sem responsabilidade por alta carga; apenas suprir necessidades de experimento. + +| Nº | Tipo | Parâmetros | +| - | - | - | +| 1 | CPU | 1 núcleo+ | +| 2 | Arquitetura CPU | x86 ou ARM | +| 3 | Memória | 1 GB+ | +| 4 | Disco | HDD ou SSD | +| 5 | Docker | Suportado | +| 6 | Rede | Local/sem rede OK | +| 7 | SO | Windows, Linux, macOS | +| 8 | LB | Não | +| 9 | Mín. nós | 1 | + +## Ambiente de produção + +| Nº | Tipo | Parâmetros | +| - | - | - | +| 1 | CPU | 2 × 12 núcleos+ | +| 2 | Tipo de CPU | x86/ARM | +| 3 | Memória | 64 GB+ | +| 4 | Disco | HDD/SSD (recomendado SSD) | +| 5 | Rede | 10 Gbps+ | +| 6 | SO | Preferir Linux | +| 8 | LB | Recomendado usar balanceador | +| 9 | Mín. nós | 4 nós | + +## Serviço de especialistas + +Se tiver dúvidas se o seu hardware atende produção, ou busca redução de custos, contacte a equipa RustFS para consultoria especializada: 400-033-5363. diff --git a/docs/pt/installation/index.md b/docs/pt/installation/index.md new file mode 100644 index 0000000..16eedc4 --- /dev/null +++ b/docs/pt/installation/index.md @@ -0,0 +1,8 @@ +--- +title: "Guia de Instalação do RustFS" +description: "Visão geral das opções de instalação do RustFS" +--- + +# Guia de Instalação do RustFS + +Esta secção apresenta uma visão geral das opções de instalação do RustFS em diferentes ambientes. O conteúdo detalhado será disponibilizado em breve para a língua portuguesa. \ No newline at end of file diff --git a/docs/pt/installation/linux.md b/docs/pt/installation/linux.md new file mode 100644 index 0000000..04c7b95 --- /dev/null +++ b/docs/pt/installation/linux.md @@ -0,0 +1,267 @@ +--- +title: "Instalar RustFS no Linux" +description: "Guia rápido para instalar o RustFS em Linux" +--- + +# Instalar RustFS no Linux + +## 1. Antes de instalar + +Esta página cobre os três modos de instalação do RustFS. O modo MNMD (multi‑nó, multi‑disco) oferece performance, segurança e escalabilidade de nível empresarial, com diagrama de referência. +Antes de prosseguir, consulte: + +1) Modos de arranque: escolha o modo Linux apropriado +2) Checklists: verifique se cumpre os requisitos de produção (se não for produção, pode simplificar) + +## 2. Pré‑requisitos + +1) Versão do sistema operativo +2) Firewall +3) Hostname +4) Memória +5) Sincronização de tempo +6) Planeamento de capacidade +7) Planeamento de discos +8) Planeamento de capacidade +9) Tiering de dados + +### 2.1 Versão do SO + +Recomendamos kernel Linux ≥ 4.x; para melhor IO e rede, use 5.x ou superior. +Distribuições sugeridas: Ubuntu 22.04, RHEL 8.x. + +### 2.2 Firewall + +Verifique o estado do firewall: + +```bash +systemctl status firewalld +``` + +Se “active”, pode desativar: + +```bash +systemctl stop firewalld +systemctl disable firewalld +``` + +Ou apenas liberar a porta 9000 do RustFS: + +```bash +firewall-cmd --zone=public --add-port=9000/tcp --permanent +firewall-cmd --reload +``` +Todas as máquinas do cluster devem usar a MESMA porta de escuta. Se usar 9000, todos os nós devem usar 9000. + +### 2.3 Hostname + +O cluster requer hostnames consistentes e contínuos. Duas opções: + +1) DNS +2) `/etc/hosts` + +```bash +vim /etc/hosts +127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4 +::1 localhost localhost.localdomain localhost6 localhost6.localdomain6 +192.168.1.1 node1 +192.168.1.2 node2 +192.168.1.3 node3 +192.168.1.4 node4 +``` + +### 2.4 Memória + +Mínimo 2 GB para testes; produção recomenda 64 GB+. + +### 2.5 Sincronização de tempo + +Para consistência multi‑nó, sincronize via `ntp`/`timedatectl`/`timesyncd`. + +Verifique o estado: + +```bash +timedatectl status +``` + +Se “synchronized”, está ok. + +## 3. Utilizador de serviço + +Recomendamos criar um utilizador sem login para executar o RustFS. No `rustfs.service`, o padrão é `rustfs-user`/`rustfs-user`. +Crie grupo/usuário e atribua permissões ao diretório de dados conforme necessário. + +## 4. Download e instalação + +Instale wget ou curl e descarregue o binário do RustFS. + +```bash +# Download +wget https://dl.rustfs.com/artifacts/rustfs/release/rustfs-linux-x86_64-latest.zip +unzip rustfs-linux-x86_64-latest.zip +chmod +x rustfs +mv rustfs /usr/local/bin/ +``` + +### 5. Variáveis de ambiente + +1) Criar ficheiro de configuração + +```bash +sudo tee /etc/default/rustfs </dev/null 2>&1 || true + endscript +} +EOF +``` + +### 7. Serviço systemd + +1) Criar unit +```bash +sudo tee /etc/systemd/system/rustfs.service < Este guia foca o arranque rápido usando o pacote gráfico de um clique do RustFS. + +## 1. Preparação + +Atenção: + +> O modo gráfico suporta apenas SNSD (single node, single disk) e é indicado para desenvolvimento, debug e testes. + +1. Para detalhes de modos de arranque, veja [Modos](../mode/) +2. Descarregue o instalador, ajuste permissões e inicie + +## 2. Download + +Vá ao site oficial e descarregue a versão mais recente do instalador do RustFS. + +## 3. Permissões + +No macOS, confirme que a aplicação tem permissões de execução. + +## Iniciar com duplo clique + +1. Faça duplo clique no ícone da aplicação +2. Clique para configurar o disco +3. Clique em "Start Service" para iniciar o RustFS + +macOS start + +## 4. Alterar configurações + +Clique no botão de configuração (ícone de engrenagem) no canto superior direito para ajustar: + +1. Porta padrão do servidor +2. Nome de utilizador e palavra‑passe do admin +3. Diretório do disco + +Configuração RustFS no macOS + +## 5. Aceder ao Console + +Depois de iniciar, aceda a `http://127.0.0.1:7001` para abrir o console. diff --git a/docs/pt/installation/mode/images/1.jpg b/docs/pt/installation/mode/images/1.jpg new file mode 100644 index 0000000..872234a Binary files /dev/null and b/docs/pt/installation/mode/images/1.jpg differ diff --git a/docs/pt/installation/mode/images/2.jpg b/docs/pt/installation/mode/images/2.jpg new file mode 100644 index 0000000..cc9943d Binary files /dev/null and b/docs/pt/installation/mode/images/2.jpg differ diff --git a/docs/pt/installation/mode/images/lb.jpg b/docs/pt/installation/mode/images/lb.jpg new file mode 100644 index 0000000..346663e Binary files /dev/null and b/docs/pt/installation/mode/images/lb.jpg differ diff --git a/docs/pt/installation/mode/index.md b/docs/pt/installation/mode/index.md new file mode 100644 index 0000000..8312422 --- /dev/null +++ b/docs/pt/installation/mode/index.md @@ -0,0 +1,46 @@ +--- +title: "Modos de arranque" +description: "Quantos modos de arranque o RustFS oferece?" +--- + +# Modos de arranque + +O RustFS suporta três modos: + +- Single Node Single Disk (SNSD): um único disco numa só máquina +- Single Node Multiple Disk (SNMD): múltiplos discos numa só máquina +- Multiple Node Multiple Disk (MNMD): múltiplas máquinas com múltiplos discos + +## Modo SNSD (Single Node Single Disk) + +> Indicado para cargas não críticas e baixa densidade. Em produção, mantenha backups para evitar risco. + +Uma máquina com um único disco de dados; todos os dados residem nesse disco. + +Arquitetura: + +RustFS Single Node Single Disk Mode + +## Modo SNMD (Single Node Multiple Disk) + +> Para cargas médias não críticas. Em produção, perda de até M discos não implica risco de dados; perda do servidor inteiro ou >M discos leva a perda de dados. + +Uma máquina com múltiplos discos. Os objetos são fragmentados e distribuídos entre discos. + +Um bloco é dividido em K fragmentos de dados e M de paridade; tolera perda de até M fragmentos de paridade e requer K dados para reconstrução. + +Exemplo: + +RustFS Single Node Multiple Disk Mode + +## Modo MNMD (Multiple Node Multiple Disk) + +> Para cargas críticas em produção. Requer ajuste por especialistas considerando concorrência, throughput, cenários e pressão. + +Mínimo 4 servidores; cada servidor com pelo menos 1 disco para formar um cluster distribuído seguro. + +Com balanceador de carga, dados podem ser escritos em qualquer servidor. Exemplo padrão 12+4: um bloco divide‑se em 12 de dados + 4 de paridade, distribuídos em discos distintos de servidores distintos. + +Falha de 1 servidor não afeta a segurança dos dados. Danos em até 4 discos permanecem tolerados. + +RustFS Multiple Node Multiple Disk Mode diff --git a/docs/pt/installation/network-checklists.md b/docs/pt/installation/network-checklists.md new file mode 100644 index 0000000..e290890 --- /dev/null +++ b/docs/pt/installation/network-checklists.md @@ -0,0 +1,95 @@ +--- +title: "Checklist de rede" +description: "Checklist de rede para implantação empresarial do RustFS" +--- + +# Checklist de rede + +## 1. Desenho da arquitetura de rede + +### Planeamento básico +- Verificação da topologia (estrela/anel/malha) para alta disponibilidade +- Verificação de caminhos redundantes: pelo menos dois enlaces físicos independentes entre nós +- Planeamento de largura de banda: Tráfego estimado de leitura/gravação × nº de nós × nº de réplicas + 20% de margem + +### Planeamento de IP +- [ ] Separar rede de gestão e rede de dados +- [ ] Alocar bloco de IPs contínuos aos nós de armazenamento (sugestão: /24) +- [ ] Reservar pelo menos 15% dos IPs para expansão + +--- + +## 2. Requisitos de hardware +### Switches +| Item | Requisito | +|------|-----------| +| Backplane | ≥ capacidade de encaminhamento em linha de todas as portas × 1,2 | +| Tipo de portas | 10G/25G/100G SFP+/QSFP+ óticas | +| Tabela de fluxos | ≥ nº de nós × 5 | +| STP | Habilitar RSTP/MSTP com convergência rápida | + +### Ligações físicas +- [ ] Teste de atenuação de fibra (monomodo ≤ 0,35 dB/km) +- [ ] Verificação de cruzamento de portas (nó A eth0 ↔ nó B eth0) +- [ ] Etiquetagem de cabos (IP de origem/destino + nº da porta) + +--- + +## 3. Sistema operativo e tuning de rede +### Parâmetros de kernel +```bash +# Verificar as seguintes definições +net.core.rmem_max = 16777216 +net.core.wmem_max = 16777216 +net.ipv4.tcp_keepalive_time = 600 +net.ipv4.tcp_slow_start_after_idle = 0 +``` + +### Configuração de NIC +- [ ] Jumbo frame (MTU=9000, com suporte end‑to‑end) +- [ ] Modo de bonding (recomendado LACP mode4) +- [ ] Desativar IPv6 (se não usado) + +--- + +## 4. Segurança +### Regras de firewall +```bash +# Portas necessárias +- TCP 443 (HTTPS API) +- TCP 9000 (S3 compatível) +- TCP 7946 (Serf) +- UDP 4789 (VxLAN) +``` + +### Controlo de acesso +- Segurança de porta no switch (limite de MAC) +- Túnel IPSec entre nós de armazenamento +- Interface de gestão com TLS 1.3 + +--- + +## 5. Testes de desempenho +### Itens de benchmark +1. Latência entre nós: `iperf3 -s 8972 ` +2. Largura de banda cross‑rack: `iperf3 -c -P 8 -t 30` +3. Failover: desconectar link crítico e observar tempo de recuperação + +### Critérios de aceitação +| Métrica | Requisito | +|--------|-----------| +| Latência | ≤1 ms (mesmo DC) / ≤5 ms (entre AZs) | +| Utilização de banda | Pico ≤70% da capacidade projetada | +| Failover | Convergência BPDU < 500 ms | + +--- + +## 6. Registos e documentação +1. Diagrama de topologia (ligações físicas e IP lógicos) +2. Backup de configurações de switch (com timestamp) +3. Relatório de testes baseline (com dados brutos) +4. Registo de mudanças (com janela de manutenção) + +> Dica: antes da produção, execute teste de stress por 72 h simulando 110% do pico de tráfego. + +Esta checklist cobre pontos críticos para implantação de armazenamento distribuído; para apoio oficial, contacte a equipa RustFS. \ No newline at end of file diff --git a/docs/pt/installation/security-checklists.md b/docs/pt/installation/security-checklists.md new file mode 100644 index 0000000..fbe3748 --- /dev/null +++ b/docs/pt/installation/security-checklists.md @@ -0,0 +1,80 @@ +--- +title: "Checklist de segurança" +description: "Checklist de segurança para implantações empresariais do RustFS (licença Apache 2.0, desenvolvido em Rust)." +--- + +# Checklist de segurança + +> Para ajudar na implantação segura do RustFS em ambientes empresariais, reunimos abaixo as melhores práticas recomendadas. Verifique item a item durante a implantação para garantir segurança e confiabilidade. + +## 1. Autenticação e controlo de acesso + +- Uso de chaves compatíveis com S3 + O RustFS utiliza mecanismo de assinatura similar ao AWS Signature V4. Cada utilizador/serviço deve usar Access Key e Secret Key válidas. Nunca ignore autenticação. + +- Políticas de acesso com privilégio mínimo + Defina políticas por função/utilizador com base no princípio do privilégio mínimo. Configure políticas de grupo e de utilizador, especificando operações S3 permitidas. Por padrão, operações não explicitamente autorizadas devem ser recusadas. + +## 2. Criptografia de transporte (TLS/SSL) + +- Ativar TLS/SSL + Configure certificados SSL e chaves privadas válidos. Para acesso externo e interno, considere domínios/certificados separados. Use TLS 1.2 ou superior. + +- Gestão de certificados + Utilize CA confiável (ou CA interna). Evite certificados expirados/autofirmados. Restrinja permissões dos ficheiros de chave privada apenas ao processo RustFS/usuário dedicado. + +- Múltiplos domínios e suites criptográficas + Configure certificados distintos para múltiplos domínios. Use algoritmos recomendados (ex.: RSA 2048 ou ECC 256) para geração de chaves. + +## 3. Variáveis de ambiente e proteção de credenciais + +- Alterar credenciais padrão + Se a instalação inicial usar credenciais padrão (ex.: `rustfsadmin`/`rustfsadmin`), altere imediatamente para senhas fortes e aleatórias. + +- Armazenamento seguro de credenciais + Não faça hard‑code de senhas em scripts, imagens ou logs. Utilize variáveis de ambiente ou Kubernetes Secrets. + +## 4. Registos e auditoria + +- Ativar auditoria + O RustFS pode exportar auditoria para HTTP Webhook, Kafka, ELK, Splunk, etc. + +- Recolha de logs + Em systemd/Docker/K8s, recolha e analise logs de forma padronizada. Recomendado integrar com ELK/Grafana Loki. + +- Monitorização e alertas + Configure alertas para falhas de login, acessos fora de hora, deleções em massa e outras anomalias. + +- Observabilidade + O RustFS suporta implantação observável, permitindo afinar tempos de execução por função e otimizar conforme o ambiente. + +## 5. Restrições de acesso à API + +- Restringir acesso de rede + Por padrão, o S3 API do RustFS escuta na porta 9000 e o console de gestão na 9090. Limite IPs de origem via firewall/security groups. + +- Isolamento e proxy + Exponha o serviço por reverse proxy (ex.: Nginx) e evite expor diretamente os IPs dos nós de armazenamento. + +- Fechar portas desnecessárias + Desative portas/interfaces não utilizadas. Não exponha o console de gestão à Internet pública. + +## 6. Dados imutáveis (WORM) + +- Versionamento e bloqueio de objetos + Ative versionamento e políticas de bloqueio para cumprir requisitos regulatórios (ex.: finanças, governo). + +## 7. Atualizações e gestão de versões + +- Patches e upgrades em dia + Acompanhe comunicados oficiais, atualize periodicamente e leia notas de versão para mitigar vulnerabilidades. + +- Atualização sem interrupção + O RustFS suporta atualização por rolling restart nó a nó, evitando downtime. + +- SO e dependências + Monitore CVEs/atualizações do SO e componentes (ex.: OpenSSL). + +--- + +Esta é a checklist de segurança para implantação empresarial do RustFS. Revise antes da produção e reavalie periodicamente para reduzir riscos e aumentar a estabilidade. diff --git a/docs/pt/installation/software-checklists.md b/docs/pt/installation/software-checklists.md new file mode 100644 index 0000000..1324d81 --- /dev/null +++ b/docs/pt/installation/software-checklists.md @@ -0,0 +1,66 @@ +--- +title: "Checklist de software" +description: "Pontos de atenção de SO, binários e dependências ao instalar o RustFS" +--- + +# Checklist de implantação de software do RustFS + +RustFS é um armazenamento de objetos distribuído de alto desempenho, 100% compatível com S3, sob licença Apache 2.0. Desenvolvido em Rust com segurança de memória, executa em Linux/Windows/macOS (x86/ARM), com implantação flexível e extensível (plugins). +Abaixo, itens essenciais para garantir uma implantação estável em produção. + +## Requisitos do sistema + +- Sistema operativo: preferir Linux LTS (Ubuntu 20.04+/22.04, RHEL 8/9, etc.); kernel ≥ 5.x. Em Linux 5.x+, o RustFS pode usar `io_uring` para melhor throughput. +- CPU e memória: x86_64/ARM suportados. Mínimo 2 GB para testes; produção recomenda 64 GB+. Dimensione memória segundo dados e concorrência. +- Desativar serviços intrusivos: evite scanners/auditores de FS (mlocate/plocate/updatedb/auditd/AV) que conflitam com I/O. Caso não possa desativar, exclua o caminho de dados do RustFS. + +O RustFS tira proveito de io_uring (Linux 5.1+, maduro em 5.10+), oferecendo I/O assíncrono com menor latência que epoll/threads — ideal para alta concorrência. + +### Sugestões + +- Use distros empresariais com kernel 5.x: + - Ubuntu 20.04 LTS (HWE 5.15+) + - Ubuntu 22.04 LTS (5.15+) + - CentOS Stream 9 / RHEL 9 + - Debian 12 (6.x) +- Em kernels antigos (4.x), atualize para tirar proveito do desempenho. + +## Verificação e implantação de binários + +- Download oficial: obtenha binários apenas de canais oficiais do RustFS. +- Integridade: verifique checksums (SHA256/assinaturas) com `sha256sum` ou ferramentas de assinatura. +- Consistência: em clusters, use a mesma versão em todos os nós. +- Local de instalação: mova para `/usr/local/bin` e `chmod +x`. Se usar systemd, confirme caminhos no unit file. + +## Sistema de ficheiros e layout de discos + +- Disco dedicado: acesso exclusivo aos discos de dados; não misture com sistema ou outros apps. +- Tipo de FS: XFS/Ext4 com opções de performance (ex.: `noatime,nodiratime,nobarrier` conforme o caso). +- Configuração de discos: prefira JBOD; confie a confiabilidade ao EC do RustFS, não ao RAID de hardware. +- Montagem e permissões: garanta RW ao usuário do serviço. Em `/etc/fstab`, considere `noexec`/`nodev`. Assegure permissões adequadas. + +## Dependências do sistema + +- Sincronização de tempo: essencial em multi‑nó (ntp/chrony/timedatectl). Verifique `timedatectl status` (synchronized). +- Hostname/DNS: configure nomes consistentes e resoluções corretas (DNS ou `/etc/hosts`). +- Conectividade: valide ping entre nós e portas abertas (padrão 9000). Em firewalls: `firewall-cmd --add-port=9000/tcp`. +- TLS/certificados: se usar HTTPS, instale cadeia raiz e configure caminhos dos certificados/keys no RustFS. +- Pacotes: garanta toolchain GNU e libs cripto (openssl/gnutls). Instale conforme avisos do SO. + +## Utilizador de execução e contexto de segurança + +- Utilizador dedicado: crie usuário (ex.: `rustfs-user`) para rodar o serviço; ajuste ownership (chown) do diretório de dados. +- Permissões: binários/configs legíveis ao usuário de execução; restrinja diretórios irrelevantes. Dados: `700/750`. +- SELinux/AppArmor: ajuste políticas para binários/dados; em testes, pode usar permissivo, avaliando riscos. +- systemd: valide `User=`/`ExecStart=` e variáveis; habilite restart automático. + +## Outros + +- Monitorização e logs: instale Prometheus + Grafana; configure rotação de logs. +- Ferramentas de operação: pode usar AWS CLI, s3cmd, etc. +- Escalabilidade: RustFS suporta plugins e vários modos de implantação; comece simples e ative recursos avançados depois. +- Plano de rollback: garanta backups de configuração e estratégia de retorno antes de produção. + +Estas listas cobrem os aspetos principais do software para implantação do RustFS. Com as boas práticas e io_uring em Linux modernos, o RustFS fornece armazenamento de objetos eficiente e fiável. + + diff --git a/docs/pt/installation/windows/images/setting.jpg b/docs/pt/installation/windows/images/setting.jpg new file mode 100644 index 0000000..bbefff5 Binary files /dev/null and b/docs/pt/installation/windows/images/setting.jpg differ diff --git a/docs/pt/installation/windows/images/windows-setup.jpg b/docs/pt/installation/windows/images/windows-setup.jpg new file mode 100644 index 0000000..12099cb Binary files /dev/null and b/docs/pt/installation/windows/images/windows-setup.jpg differ diff --git a/docs/pt/installation/windows/index.md b/docs/pt/installation/windows/index.md new file mode 100644 index 0000000..7dd2d2e --- /dev/null +++ b/docs/pt/installation/windows/index.md @@ -0,0 +1,45 @@ +--- +title: "Instalar RustFS no Windows" +description: "Arranque do RustFS no Windows com um clique" +--- + +# Instalar RustFS no Windows + +## 1. Preparação + +Atenção: + +> O modo de arranque no Windows suporta apenas SNSD (single node, single disk), indicado para desenvolvimento, debug e testes. + +1. Para detalhes dos modos, veja [Modos](../mode/) +2. Descarregue o instalador, ajuste permissões e inicie + +## 2. Download + +Vá ao site oficial e descarregue a versão mais recente do instalador do RustFS. + +## 3. Permissões + +No Windows, confirme que a aplicação tem permissões de execução. + +## Iniciar com duplo clique + +1. Faça duplo clique no ícone da aplicação +2. Clique para configurar o disco +3. Clique em "Start Service" para iniciar o RustFS + +Windows start + +## 4. Alterar configurações + +Clique no botão de configuração (ícone de engrenagem) no canto superior direito para ajustar: + +1. Porta padrão do servidor +2. Nome de utilizador e palavra‑passe do admin +3. Diretório do disco + +Configuração RustFS no Windows + +## 5. Aceder ao Console + +Depois de iniciar, aceda a `http://127.0.0.1:7001` para abrir o console. diff --git a/docs/pt/introduction.md b/docs/pt/introduction.md new file mode 100644 index 0000000..10223af --- /dev/null +++ b/docs/pt/introduction.md @@ -0,0 +1,37 @@ +--- +title: "O que é o RustFS?" +description: "RustFS é uma solução de armazenamento de objetos: software livre, distribuído e compatível com S3 sob licença Apache 2.0." +--- + +# O que é o RustFS? + +RustFS é um armazenamento de objetos simples, eficiente e distribuído. +É também uma solução aberta e livre, 100% compatível com o protocolo S3, distribuída sob a licença Apache 2.0. O RustFS é escrito em Rust, uma linguagem amplamente adotada e com segurança de memória. +É um produto de armazenamento de objetos amigável ao uso comercial, com contribuições de engenheiros de todo o mundo, capaz de substituir muitas soluções não amigáveis em termos de licenciamento. + +O RustFS passará de uso comercial para open source com lançamento global, ajudando a reduzir custos de armazenamento e a melhorar a segurança dos dados. + +## Sistemas Operativos e CPUs suportados + +Pode executar o RustFS praticamente em qualquer CPU e sistema operativo: Linux, Unix, Windows, macOS, FreeBSD, Docker e até em gateways de borda. +Arquiteturas de CPU suportadas: x86, ARM, entre outras. + +## Características do RustFS + +- S3 compatível: 100% compatível com o protocolo S3; excelente interoperabilidade com big data, data lakes, software de backup, processamento de imagem e aplicações industriais. +- Distribuído: o RustFS é um armazenamento de objetos distribuído, adaptado a múltiplas necessidades. +- Comercialmente amigável: 100% open source sob Apache v2.0, adequado para uso comercial. +- Rápido: Rust atinge desempenho próximo ao de C; o RustFS apresenta performance muito elevada. +- Seguro: desenvolvido em Rust (segurança de memória), proporcionando elevada segurança. +- Multiplataforma: funciona em Windows, macOS e Linux. +- Extensível: suporta plugins personalizados para diversas necessidades. +- Personalizável: por ser open source, pode adicionar plugins e adaptar o sistema. +- Cloud‑native: suporta deploy com Docker e ambientes nativos de cloud. + +## Valores do RustFS + +Ajudar a humanidade a elevar a segurança dos dados e reduzir o custo de armazenamento. + +## Visão do RustFS + +Que cada agente/entidade de IA pessoal no mundo possa usar o RustFS para armazenar dados. diff --git a/docs/pt/license.md b/docs/pt/license.md new file mode 100644 index 0000000..df40fd5 --- /dev/null +++ b/docs/pt/license.md @@ -0,0 +1,205 @@ +--- +title: Licença open source do RustFS +description: O RustFS é distribuído sob a licença Apache v2.0, 100% amigável para uso comercial +--- + +# Licença open source do RustFS + +## Licença open source + +- O RustFS é distribuído sob a licença Apache v2.0 (100% amigável para uso comercial) +- [Apache v2.0](https://www.apache.org/licenses/LICENSE-2.0) + +## Termos da licença + +_Version 2.0, January 2004_ +http://www.apache.org/licenses/ + +### Terms and Conditions for use, reproduction, and distribution + +#### 1. Definitions + +“License” shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +“Licensor” shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +“Legal Entity” shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, “control” means **(i)** the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the +outstanding shares, or **(iii)** beneficial ownership of such entity. + +“You” (or “Your”) shall mean an individual or Legal Entity exercising +permissions granted by this License. + +“Source” form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +“Object” form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +“Work” shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +“Derivative Works” shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +“Contribution” shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +“submitted” means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as “Not a Contribution.” + +“Contributor” shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +#### 2. Grant of Copyright License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +#### 3. Grant of Patent License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +#### 4. Redistribution + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +* **(a)** You must give any other recipients of the Work or Derivative Works a copy of +this License; and +* **(b)** You must cause any modified files to carry prominent notices stating that You +changed the files; and +* **(c)** You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source form +of the Work, excluding those notices that do not pertain to any part of the +Derivative Works; and +* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any +Derivative Works that You distribute must include a readable copy of the +attribution notices contained within such NOTICE file, excluding those notices +that do not pertain to any part of the Derivative Works, in at least one of the +following places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided along +with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents of +the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works that +You distribute, alongside or as an addendum to the NOTICE text from the Work, +provided that such additional attribution notices cannot be construed as +modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +#### 5. Submission of Contributions + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +#### 6. Trademarks + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +#### 7. Disclaimer of Warranty + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an “AS IS” BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +#### 8. Limitation of Liability + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +#### 9. Accepting Warranty or Additional Liability + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +_END OF TERMS AND CONDITIONS_ + +### APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets `[]` replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included on +the same “printed page” as the copyright notice for easier identification within +third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/docs/pt/sdk/index.md b/docs/pt/sdk/index.md new file mode 100644 index 0000000..e48d16b --- /dev/null +++ b/docs/pt/sdk/index.md @@ -0,0 +1,34 @@ +--- +title: "Visão geral dos SDKs" +description: "Quais SDKs S3 posso usar com o RustFS? Esta página explica as opções e recomendações." +--- + +# Visão geral dos SDKs + +RustFS é 100% compatível com o protocolo S3. Você pode: + +1. Usar o console para gerir o RustFS; +2. Usar clientes S3 para gerir o RustFS; +3. Integrar no seu aplicativo via SDK para operar/gerir objetos. + +## Glossário rápido + +S3 é o nome do serviço de armazenamento de objetos da Amazon, cujo protocolo/SDKs foram documentados publicamente. A maioria das soluções de object storage atuais segue o protocolo S3. Em muitos contextos “S3” é usado como sinónimo de “armazenamento de objetos” ou “protocolo S3”. + +## 1. Recomendações de SDK + +Há SDKs maduros mantidos há anos. Os SDKs oficiais da AWS para S3 passaram por extensos testes e otimizações, com baixíssima taxa de erros. Recomendamos usar diretamente os SDKs S3 oficiais da AWS para se comunicar com o RustFS. + +Se já possui confiança em outro SDK/fornecedor compatível com S3, também pode utilizá‑lo. + +Observação: alguns fornecedores na China modificam SDKs e nem sempre suportam recursos S3 mais recentes. Em ambientes globais, muitas soluções não recomendam esses SDKs específicos. + +## 2. O SDK do MinIO funciona com RustFS? + +Sim. O SDK do MinIO é suportado e compatível. Ajuste apenas o endpoint e as credenciais (AK/SK) para usar com RustFS. + +## 3. E se o SDK for incompatível? + +Se o SDK que utiliza não suportar corretamente S3/MinIO/RustFS, recomendamos substituí‑lo por um SDK compatível e realizar a migração no seu aplicativo. + + diff --git a/docs/pt/sdk/java.md b/docs/pt/sdk/java.md new file mode 100644 index 0000000..78343cd --- /dev/null +++ b/docs/pt/sdk/java.md @@ -0,0 +1,286 @@ +--- +title: "Java SDK" +description: "Este documento explica como usar o AWS S3 Java SDK com o RustFS." +--- + +# Java SDK + +RustFS é compatível com o protocolo S3 e integra com o AWS S3 SDK. Este guia usa o AWS SDK para Java como exemplo para configurar o ambiente, conectar ao RustFS e realizar operações básicas. + +## 1. Integrar o AWS S3 Java SDK + +### 1.1 Criar projeto Maven + +Estrutura sugerida: + +``` +rustfs-java-s3-demo/ +├── pom.xml +└── src/ + └── main/ + └── java/ + └── com/ + └── example/ + └── RustfsS3Example.java +``` + +### 1.2 Dependências + +Em `pom.xml`: + +```xml + + + software.amazon.awssdk + s3 + 2.25.27 + + +``` + +> Recomenda‑se o AWS SDK v2 (suporta assíncrono, reativo, etc.). + +--- + +## 2. Conectar e usar o RustFS + +### 2.1 Inicializar cliente S3 + +```java +package com.example; + +import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; +import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.s3.S3Client; +import software.amazon.awssdk.services.s3.model.*; + +import java.net.URI; +import java.nio.file.Paths; + +public class RustfsS3Example { + + public static void main(String[] args) { + // 1. Inicializar cliente S3 + S3Client s3 = S3Client.builder() + .endpointOverride(URI.create("http://192.168.1.100:9000")) // endereço do RustFS + .region(Region.US_EAST_1) // valor arbitrário; RustFS não valida a região + .credentialsProvider( + StaticCredentialsProvider.create( + AwsBasicCredentials.create("rustfsadmin", "rustfssecret") + ) + ) + .forcePathStyle(true) // necessário: RustFS requer Path‑Style + .build(); + + // 2. Criar bucket + String bucket = "my-bucket"; + try { + s3.createBucket(CreateBucketRequest.builder().bucket(bucket).build()); + System.out.println("Bucket created: " + bucket); + } catch (BucketAlreadyExistsException | BucketAlreadyOwnedByYouException e) { + System.out.println("Bucket already exists."); + } + + // 3. Upload de arquivo + s3.putObject( + PutObjectRequest.builder().bucket(bucket).key("hello.txt").build(), + Paths.get("hello.txt") + ); + System.out.println("Uploaded hello.txt"); + + // 4. Download de arquivo + s3.getObject( + GetObjectRequest.builder().bucket(bucket).key("hello.txt").build(), + Paths.get("downloaded-hello.txt") + ); + System.out.println("Downloaded hello.txt"); + + // 5. Listar objetos + ListObjectsV2Response listResponse = s3.listObjectsV2(ListObjectsV2Request.builder().bucket(bucket).build()); + listResponse.contents().forEach(obj -> System.out.println("Found object: " + obj.key())); + + // 6. Excluir objeto + s3.deleteObject(DeleteObjectRequest.builder().bucket(bucket).key("hello.txt").build()); + System.out.println("Deleted hello.txt"); + + // 7. Excluir bucket (opcional) + // s3.deleteBucket(DeleteBucketRequest.builder().bucket(bucket).build()); + } +} +``` + +--- + +## 3. FAQ e troubleshooting + +| Problema | Causa | Solução | +| -------------------------------------- | ------------------------------------ | ----------------------------------------- | +| `S3Exception: 301 Moved Permanently` | Path‑style desativado ou região incorreta | Ative `.forcePathStyle(true)` e use região arbitrária | +| `ConnectException: Connection refused` | RustFS inativo ou porta incorreta | Verifique serviço e porta | +| `403 Forbidden` | AccessKey/SecretKey incorretas | Corrija credenciais | +| Upload sem resposta | SDK usa HTTPS por padrão e RustFS pode exigir HTTP | Use `http://` em `endpointOverride` ou configure TLS | + +--- + +## 4. Anexos + +### 4.1 Pacote e execução Maven + +```bash +mvn clean package +``` + +```bash +java -cp target/rustfs-java-s3-demo-1.0-SNAPSHOT.jar com.example.RustfsS3Example +``` + +### 4.2 Recomendações de configuração do RustFS + +- Se usar HTTP, desabilite validação SSL do cliente +- Habilite CORS (para front‑end Web) +- Configure limites como `max_object_size` e `max_part_size` + +--- + +A seguir, exemplos avançados do Java SDK: Presigned URL e Multipart Upload. + +--- + +## 5. Funcionalidades avançadas + +### 5.1 Presigned URL + +> Permite acesso temporário sem expor credenciais (útil para upload/download em navegador). + +#### 5.1.1 Dependência (módulo `s3-presigner`) + +```xml + + software.amazon.awssdk + s3-presigner + 2.25.27 + +``` + +#### 5.1.2 Gerar link de download (GET) + +```java +import software.amazon.awssdk.services.s3.presigner.S3Presigner; +import software.amazon.awssdk.services.s3.presigner.model.GetObjectPresignRequest; + +S3Presigner presigner = S3Presigner.builder() + .endpointOverride(URI.create("http://192.168.1.100:9000")) + .region(Region.US_EAST_1) + .credentialsProvider( + StaticCredentialsProvider.create( + AwsBasicCredentials.create("rustfsadmin", "rustfssecret") + ) + ) + .build(); + +GetObjectRequest getObjectRequest = GetObjectRequest.builder() + .bucket("my-bucket") + .key("hello.txt") + .build(); + +GetObjectPresignRequest presignRequest = GetObjectPresignRequest.builder() + .getObjectRequest(getObjectRequest) + .signatureDuration(Duration.ofMinutes(15)) // válido por 15 minutos + .build(); + +PresignedGetObjectRequest presignedRequest = presigner.presignGetObject(presignRequest); + +System.out.println("Presigned URL: " + presignedRequest.url()); +``` + +> 🔗 Abra o link no navegador para acessar o objeto. + +#### 5.1.3 Gerar link de upload (PUT) + +```java +PutObjectRequest putRequest = PutObjectRequest.builder() + .bucket("my-bucket") + .key("upload.txt") + .build(); + +PresignedPutObjectRequest presignedPut = presigner.presignPutObject( + PutObjectPresignRequest.builder() + .putObjectRequest(putRequest) + .signatureDuration(Duration.ofMinutes(10)) + .build() +); + +System.out.println("Upload URL: " + presignedPut.url()); +``` + +--- + +### 5.2 Multipart Upload + +> Recomendado para arquivos grandes; suporta retomada em redes instáveis. + +#### 5.2.1 Iniciar upload multipart + +```java +CreateMultipartUploadRequest createRequest = CreateMultipartUploadRequest.builder() + .bucket("my-bucket") + .key("bigfile.zip") + .build(); + +CreateMultipartUploadResponse createResponse = s3.createMultipartUpload(createRequest); +String uploadId = createResponse.uploadId(); +``` + +#### 5.2.2 Enviar partes + +```java +List completedParts = new ArrayList<>(); +for (int i = 1; i <= 3; i++) { + String partPath = "part" + i + ".bin"; // supondo arquivos locais + UploadPartRequest uploadPartRequest = UploadPartRequest.builder() + .bucket("my-bucket") + .key("bigfile.zip") + .uploadId(uploadId) + .partNumber(i) + .build(); + + UploadPartResponse uploadPartResponse = s3.uploadPart(uploadPartRequest, Paths.get(partPath)); + completedParts.add( + CompletedPart.builder() + .partNumber(i) + .eTag(uploadPartResponse.eTag()) + .build() + ); +} +``` + +#### 5.2.3 Concluir upload multipart + +```java +CompletedMultipartUpload completedUpload = CompletedMultipartUpload.builder() + .parts(completedParts) + .build(); + +CompleteMultipartUploadRequest completeRequest = CompleteMultipartUploadRequest.builder() + .bucket("my-bucket") + .key("bigfile.zip") + .uploadId(uploadId) + .multipartUpload(completedUpload) + .build(); + +s3.completeMultipartUpload(completeRequest); +System.out.println("Multipart upload completed."); +``` + +#### 5.2.4 Abortar upload (opcional) + +```java +AbortMultipartUploadRequest abortRequest = AbortMultipartUploadRequest.builder() + .bucket("my-bucket") + .key("bigfile.zip") + .uploadId(uploadId) + .build(); + +s3.abortMultipartUpload(abortRequest); +``` diff --git a/docs/pt/sdk/js.md b/docs/pt/sdk/js.md new file mode 100644 index 0000000..91e8172 --- /dev/null +++ b/docs/pt/sdk/js.md @@ -0,0 +1,278 @@ +--- +title: "JS SDK" +description: "Este documento explica como usar o SDK JavaScript da AWS (v3) com o RustFS." +--- + +A seguir está a documentação para usar o **AWS S3 JS SDK** com o RustFS: instalação, configuração, operações básicas (upload, download, delete, list), URL pré‑assinada e upload multipart, para ambiente Node.js. + +--- + +# RustFS com AWS S3 JS SDK (Node.js) + +## 1. Visão geral + +RustFS é compatível com o protocolo S3 e pode ser acessado com o AWS SDK para JavaScript (v3). Este guia mostra como conectar e realizar operações comuns. + +--- + +## 2. Preparação + +### 2.1 Instalar SDK + +Instale os módulos necessários do AWS SDK v3: + +```bash +npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner +``` + +### 2.2 Configuração de exemplo do RustFS + +Suponha a seguinte instância RustFS: + +``` +Endpoint: http://192.168.1.100:9000 +Access Key: rustfsadmin +Secret Key: rustfssecret +``` + +--- + +## 3. Inicializar o cliente S3 + +```js +import { S3Client } from "@aws-sdk/client-s3"; +import { NodeHttpHandler } from "@smithy/node-http-handler"; + +const s3 = new S3Client({ + endpoint: "http://192.168.1.100:9000", // endpoint do RustFS + region: "us-east-1", // valor arbitrário + credentials: { + accessKeyId: "rustfsadmin", + secretAccessKey: "rustfssecret", + }, + forcePathStyle: true, // necessário para compatibilidade com RustFS + requestHandler: new NodeHttpHandler({ + connectionTimeout: 3000, + socketTimeout: 5000, + }), +}); +``` + +--- + +## 4. Operações básicas + +### 4.1 Criar bucket + +```js +import { CreateBucketCommand } from "@aws-sdk/client-s3"; + +await s3.send(new CreateBucketCommand({ Bucket: "my-bucket" })); +console.log("Bucket created"); +``` + +--- + +### 4.2 Upload de objeto + +```js +import { PutObjectCommand } from "@aws-sdk/client-s3"; +import { readFileSync } from "fs"; + +const data = readFileSync("hello.txt"); + +await s3.send( + new PutObjectCommand({ + Bucket: "my-bucket", + Key: "hello.txt", + Body: data, + }) +); + +console.log("File uploaded"); +``` + +--- + +### 4.3 Download de objeto + +```js +import { GetObjectCommand } from "@aws-sdk/client-s3"; +import { writeFile } from "fs/promises"; + +const response = await s3.send( + new GetObjectCommand({ Bucket: "my-bucket", Key: "hello.txt" }) +); + +const streamToBuffer = async (stream) => { + const chunks = []; + for await (const chunk of stream) chunks.push(chunk); + return Buffer.concat(chunks); +}; + +const buffer = await streamToBuffer(response.Body); +await writeFile("downloaded.txt", buffer); + +console.log("File downloaded"); +``` + +--- + +### 4.4 Listar objetos + +```js +import { ListObjectsV2Command } from "@aws-sdk/client-s3"; + +const res = await s3.send(new ListObjectsV2Command({ Bucket: "my-bucket" })); +res.Contents?.forEach((obj) => console.log(`${obj.Key} (${obj.Size} bytes)`)); +``` + +--- + +### 4.5 Excluir objeto + +```js +import { DeleteObjectCommand } from "@aws-sdk/client-s3"; + +await s3.send(new DeleteObjectCommand({ Bucket: "my-bucket", Key: "hello.txt" })); +console.log("File deleted"); +``` + +--- + +## 5. Funcionalidades avançadas + +### 5.1 URL pré‑assinada + +> Permite a terceiros usar links temporários para upload/download + +#### Download (GET) + +```js +import { GetObjectCommand } from "@aws-sdk/client-s3"; +import { getSignedUrl } from "@aws-sdk/s3-request-presigner"; + +const url = await getSignedUrl( + s3, + new GetObjectCommand({ Bucket: "my-bucket", Key: "hello.txt" }), + { expiresIn: 600 } +); + +console.log("Presigned GET URL:", url); +``` + +#### Upload (PUT) + +```js +import { PutObjectCommand } from "@aws-sdk/client-s3"; + +const url = await getSignedUrl( + s3, + new PutObjectCommand({ Bucket: "my-bucket", Key: "upload.txt" }), + { expiresIn: 600 } +); + +console.log("Presigned PUT URL:", url); +``` + +--- + +### 5.2 Upload multipart + +```js +import { + CreateMultipartUploadCommand, + UploadPartCommand, + CompleteMultipartUploadCommand, + AbortMultipartUploadCommand, +} from "@aws-sdk/client-s3"; +import { createReadStream } from "fs"; + +const bucket = "my-bucket"; +const key = "large-file.zip"; +const filePath = "./large-file.zip"; +const partSize = 5 * 1024 * 1024; // 5 MB + +// 1. Criar tarefa de upload +const createRes = await s3.send( + new CreateMultipartUploadCommand({ Bucket: bucket, Key: key }) +); +const uploadId = createRes.UploadId; + +// 2. Enviar partes +import { statSync, openSync, readSync, closeSync } from "fs"; + +const fileSize = statSync(filePath).size; +const fd = openSync(filePath, "r"); +const parts = []; + +for (let partNumber = 1, offset = 0; offset < fileSize; partNumber++) { + const buffer = Buffer.alloc(Math.min(partSize, fileSize - offset)); + readSync(fd, buffer, 0, buffer.length, offset); + + const uploadPartRes = await s3.send( + new UploadPartCommand({ + Bucket: bucket, + Key: key, + UploadId: uploadId, + PartNumber: partNumber, + Body: buffer, + }) + ); + + parts.push({ ETag: uploadPartRes.ETag, PartNumber: partNumber }); + offset += partSize; +} + +closeSync(fd); + +// 3. Concluir upload +await s3.send( + new CompleteMultipartUploadCommand({ + Bucket: bucket, + Key: key, + UploadId: uploadId, + MultipartUpload: { Parts: parts }, + }) +); + +console.log("Multipart upload completed"); +``` + +--- + +## 6. FAQ e notas + +| Problema | Causa | Solução | +| --------------------------- | -------------------- | --------------------------------------- | +| SignatureDoesNotMatch | Versão de assinatura incorreta | JS SDK v3 usa v4; confirme suporte v4 no RustFS | +| EndpointConnectionError | Endpoint incorreto ou serviço inativo | Verifique acessibilidade do RustFS | +| NoSuchKey | Objeto inexistente | Verifique `Key` | +| InvalidAccessKeyId / Secret | Credenciais incorretas | Verifique `accessKeyId` / `secretAccessKey` | +| Falha de upload (path‑style) | Path‑style desativado | Defina `forcePathStyle: true` | + +--- + +## 7. Anexo: upload via front‑end + +É possível permitir uploads diretos do navegador com URL pré‑assinada, sem expor AccessKey. + +Exemplo (HTML+JS): + +```html + + +``` + diff --git a/docs/pt/sdk/other.md b/docs/pt/sdk/other.md new file mode 100644 index 0000000..0828687 --- /dev/null +++ b/docs/pt/sdk/other.md @@ -0,0 +1,78 @@ +--- +title: "Outros SDKs" +description: "Estratégias para integrar linguagens sem SDK oficial S3 com o RustFS." +--- + +# Outros SDKs + +Se não houver SDK oficial da AWS S3 para a sua linguagem, use uma destas estratégias: + +## 1) Chamar a API HTTP diretamente (protocolo S3) + +O protocolo S3 é RESTful. Qualquer linguagem com HTTP pode implementar a integração (C, Rust, Lua, Erlang, etc.). + +Pontos-chave: + +- Assinatura: implemente AWS Signature Version 4 +- Construa headers e Canonical Request corretamente +- Use cliente HTTPS/HTTP + +Referências: + +- [https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) + +--- + +## 2) Usar CLIs/serviços intermediários de SDK existente + +Se não quiser implementar assinatura: + +### 2.1 CLI da AWS + +Exemplo via shell: + +```bash +aws s3 cp local.txt s3://mybucket/myfile.txt --endpoint-url http://rustfs.local:9000 +``` + +Ou implemente um microserviço (Node.js/Python) que encapsule o SDK; sua linguagem chama esse serviço. + +### 2.2 Proxy (Flask, FastAPI, Express) + +Expose uma API HTTP simples: + +```http +POST /upload -> o serviço usa o SDK e envia ao RustFS +GET /presigned-url -> gera URL pré‑assinada para front-end/cliente +``` + +--- + +## 3) SDKs de comunidade + +Algumas linguagens têm clientes S3 não‑oficiais: + +- Haskell: `amazonka-s3` +- Rust: `aws-sdk-rust` (ou `rusoto` – descontinuado) +- OCaml: possível via `cohttp` +- Delphi: há bibliotecas comerciais + +Avalie estabilidade, documentação e compatibilidade antes do uso. + +--- + +## 4) Delegar upload ao cliente/plataforma + +- Navegador/App envia diretamente com URL pré‑assinada +- Backend (Node/Python/Go) atua como proxy de upload + +--- + +## Recomendações + +| Cenário | Opção recomendada | +| ------------- | ---------------------------------- | +| Controle total/embarcado | Implementar Signature V4 | +| Linguagem com shell | Usar AWS CLI | +| Pode hospedar um gateway | Construir API S3 em Python/Node | +| Upload em front‑end | Usar URL pré‑assinada | diff --git a/docs/pt/sdk/python.md b/docs/pt/sdk/python.md new file mode 100644 index 0000000..b33d9ba --- /dev/null +++ b/docs/pt/sdk/python.md @@ -0,0 +1,241 @@ +--- +title: "Python SDK" +description: "Como usar o Boto3 (S3 Python SDK) com o RustFS: instalação, operações básicas, presigned URL e multipart." +--- + +Abaixo está a documentação para usar o **Boto3 (S3 Python SDK)** com o RustFS: instalação, conexão, operações básicas, URL pré‑assinada e upload multipart. + +--- + +# RustFS com S3 Python SDK (Boto3) + +## 1. Visão geral + +RustFS é compatível com o protocolo Amazon S3 e pode ser acessado pelo [Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html). + +Este guia mostra como integrar RustFS com Python e realizar: + +* Criar/Excluir buckets +* Upload/Download/Delete de objetos +* Listar objetos +* Gerar URL pré‑assinada +* Upload multipart para arquivos grandes + +--- + +## 2. Preparação do ambiente + +### 2.1 Informações do RustFS + +Suponha uma instância: + +``` +Endpoint: http://192.168.1.100:9000 +AccessKey: rustfsadmin +SecretKey: rustfssecret +``` + +### 2.2 Instalar Boto3 + +Recomendamos `venv`: + +```bash +python3 -m venv venv +source venv/bin/activate +pip install boto3 +``` + +> Boto3 depende de `botocore` (instala automaticamente). + +--- + +## 3. Conectar ao RustFS + +```python +import boto3 +from botocore.client import Config + +s3 = boto3.client( + 's3', + endpoint_url='http://192.168.1.100:9000', + aws_access_key_id='rustfsadmin', + aws_secret_access_key='rustfssecret', + config=Config(signature_version='s3v4'), + region_name='us-east-1' +) +``` + +> ✅ `endpoint_url`: aponta para o RustFS +> ✅ `signature_version='s3v4'`: RustFS suporta assinatura v4 +> ✅ `region_name`: RustFS não valida região (valor arbitrário) + +--- + +## 4. Operações básicas + +### 4.1 Criar bucket + +```python +bucket_name = 'my-bucket' + +try: + s3.create_bucket(Bucket=bucket_name) + print(f'Bucket {bucket_name} created.') +except s3.exceptions.BucketAlreadyOwnedByYou: + print(f'Bucket {bucket_name} already exists.') +``` + +--- + +### 4.2 Upload de arquivo + +```python +s3.upload_file('hello.txt', bucket_name, 'hello.txt') +print('File uploaded.') +``` + +--- + +### 4.3 Download de arquivo + +```python +s3.download_file(bucket_name, 'hello.txt', 'hello-downloaded.txt') +print('File downloaded.') +``` + +--- + +### 4.4 Listar objetos + +```python +response = s3.list_objects_v2(Bucket=bucket_name) +for obj in response.get('Contents', []): + print(f"- {obj['Key']} ({obj['Size']} bytes)") +``` + +--- + +### 4.5 Excluir objeto e bucket + +```python +s3.delete_object(Bucket=bucket_name, Key='hello.txt') +print('Object deleted.') + +s3.delete_bucket(Bucket=bucket_name) +print('Bucket deleted.') +``` + +--- + +## 5. Recursos avançados + +### 5.1 URL pré‑assinada + +#### 5.1.1 Link de download (GET) + +```python +url = s3.generate_presigned_url( + ClientMethod='get_object', + Params={'Bucket': bucket_name, 'Key': 'hello.txt'}, + ExpiresIn=600 # válido por 10 minutos +) + +print('Presigned GET URL:', url) +``` + +#### 5.1.2 Link de upload (PUT) + +```python +url = s3.generate_presigned_url( + ClientMethod='put_object', + Params={'Bucket': bucket_name, 'Key': 'upload-by-url.txt'}, + ExpiresIn=600 +) + +print('Presigned PUT URL:', url) +``` + +Você pode usar `curl` para enviar: + +```bash +curl -X PUT --upload-file hello.txt "http://..." +``` + +--- + +### 5.2 Upload multipart + +Indicado para arquivos >10 MB, com controle manual de partes. + +```python +import os + +file_path = 'largefile.bin' +key = 'largefile.bin' +part_size = 5 * 1024 * 1024 # 5 MB + +# 1. Iniciar upload +response = s3.create_multipart_upload(Bucket=bucket_name, Key=key) +upload_id = response['UploadId'] +parts = [] + +try: + with open(file_path, 'rb') as f: + part_number = 1 + while True: + data = f.read(part_size) + if not data: + break + + part = s3.upload_part( + Bucket=bucket_name, + Key=key, + PartNumber=part_number, + UploadId=upload_id, + Body=data + ) + + parts.append({'ETag': part['ETag'], 'PartNumber': part_number}) + print(f'Uploaded part {part_number}') + part_number += 1 + + # 2. Concluir upload + s3.complete_multipart_upload( + Bucket=bucket_name, + Key=key, + UploadId=upload_id, + MultipartUpload={'Parts': parts} + ) + print('Multipart upload complete.') + +except Exception as e: + # Abortar upload + s3.abort_multipart_upload(Bucket=bucket_name, Key=key, UploadId=upload_id) + print('Multipart upload aborted due to error:', e) +``` + +--- + +## 6. Troubleshooting + +| Problema | Causa | Solução | +| ------------------------- | ----------------- | -------------------------------------------------------------- | +| `SignatureDoesNotMatch` | Não usa v4 | Defina `signature_version='s3v4'` | +| `EndpointConnectionError` | Endpoint incorreto/serviço inativo | Verifique endpoint e serviço | +| `AccessDenied` | Credenciais/políticas incorretas | Revise AccessKey/SecretKey ou política do bucket | +| `PermanentRedirect` | Path‑style desativado | Boto3 usa virtual‑host por padrão; use path‑style via endpoint | + +--- + +## 7. Anexos: helpers rápidos + +```python +def upload_file(local_path, bucket, object_key): + s3.upload_file(local_path, bucket, object_key) + print(f"Uploaded {local_path} to s3://{bucket}/{object_key}") + +def download_file(bucket, object_key, local_path): + s3.download_file(bucket, object_key, local_path) + print(f"Downloaded s3://{bucket}/{object_key} to {local_path}") +``` + diff --git a/docs/pt/sidebar.ts b/docs/pt/sidebar.ts new file mode 100644 index 0000000..7e22ee6 --- /dev/null +++ b/docs/pt/sidebar.ts @@ -0,0 +1,122 @@ +export const zhSidebar = [ + { + text: 'Introdução', + collapsed: true, + home: true, + items: [ + { text: 'Introdução ao RustFS', link: '/pt/introduction' }, + { text: 'Arquitetura', link: '/pt/architecture' }, + { text: 'Comparação com outros armazenamentos', link: '/pt/comparison' }, + { text: 'Licença de código aberto', link: '/pt/license' }, + { + text: 'Conceitos', items: [ + { text: 'Glossário', link: '/pt/concepts/glossary' }, + { text: 'Erasure Coding', link: '/pt/concepts/erasure-coding' }, + { text: 'Disponibilidade e escalabilidade', link: '/pt/concepts/availability-and-resiliency' }, + { text: 'Verificação e auto‑recuperação de objetos', link: '/pt/concepts/object-healing' }, + { text: 'Scanner de objetos', link: '/pt/concepts/object-scanner' }, + { text: 'Limites de uso', link: '/pt/concepts/limit' }, + ], + }, + ], + }, + { + text: 'Plataformas', + collapsed: true, + home: true, + items: [ + { text: 'Bare metal e virtualização', link: '/pt/features/baremetal/' }, + { text: 'Alibaba Cloud', link: '/pt/features/aliyun/' }, + { text: 'Tencent Cloud', link: '/pt/features/qcloud/' }, + { text: 'Huawei Cloud', link: '/pt/features/huaweicloud/' }, + { text: 'VMWare Tanzu', link: '/pt/features/tanzu/' }, + { text: 'Nuvens internacionais', link: '/pt/features/aws-elastic/' }, + ], + }, + { + text: 'Funcionalidades', + collapsed: true, + home: true, + items: [ + { text: 'Distribuído', link: '/pt/features/distributed/' }, + { text: 'Registo e auditoria', link: '/pt/features/logging/' }, + { text: 'Versionamento', link: '/pt/features/versioning/' }, + { text: 'Compatibilidade S3', link: '/pt/features/s3-compatibility/' }, + { text: 'WORM (Só leitura)', link: '/pt/features/worm/' }, + { text: 'Replicação', link: '/pt/features/replication/' }, + { text: 'Encriptação', link: '/pt/features/encryption/' }, + { text: 'Lifecycle', link: '/pt/features/lifecycle/' }, + ], + }, + { + text: 'Soluções', + collapsed: true, + home: true, + items: [ + { text: 'Data Lake moderno', link: '/pt/features/data-lake/' }, + { text: 'IA e ML', link: '/pt/features/ai/' }, + { text: 'Cloud‑native', link: '/pt/features/cloud-native/' }, + { text: 'Separação compute/storage', link: '/pt/features/hdfs/' }, + { text: 'SQL', link: '/pt/features/sql-server/' }, + { text: 'Transação quantitativa', link: '/pt/features/quantitative-trading/' }, + { text: 'Indústria', link: '/pt/features/industry/' }, + { text: 'Arquivo a frio', link: '/pt/features/cold-archiving/' }, + { text: 'Vídeo', link: '/pt/features/video/' }, + { text: 'Soluções domésticas', link: '/pt/features/domestic/' }, + ], + }, + { + text: 'Instalação e Deployment', + collapsed: true, + home: true, + items: [ + { text: 'Modos de arranque', link: '/pt/installation/mode/' }, + { text: 'Seleção de hardware', link: '/pt/installation/hardware-selection' }, + { + text: 'Pré‑verificações', + link: '/pt/installation/checklists', + items: [ + { text: 'Checklist geral', link: '/pt/installation/checklists' }, + { text: 'Checklist de hardware', link: '/pt/installation/hard-checklists' }, + { text: 'Checklist de software', link: '/pt/installation/software-checklists' }, + { text: 'Checklist de rede', link: '/pt/installation/network-checklists' }, + { text: 'Checklist de segurança', link: '/pt/installation/security-checklists' }, + ] + }, + { + text: 'Guias de instalação', + link: '/pt/installation/linux', + items: [ + { text: 'Instalação no Linux', link: '/pt/installation/linux' }, + { text: 'Instalação no macOS', link: '/pt/installation/macos/' }, + { text: 'Instalação no Windows', link: '/pt/installation/windows/' }, + { text: 'Instalação com Docker', link: '/pt/installation/docker' }, + ] + }, + ] + }, + { + text: 'Guias de utilização', + collapsed: true, + home: true, + items: [ + { text: 'Gestão de buckets', link: '/pt/guide/bucket/bucket-create-and-delete' }, + { text: 'Gestão de objetos', link: '/pt/guide/bucket/object-upload-and-delete' }, + { text: 'Gestão de chaves de acesso', link: '/pt/guide/access-token' }, + { text: 'Uso do mc (MinIO Client)', link: '/pt/guide/mc' }, + { text: 'MCP', link: '/pt/guide/mcp' }, + ] + }, + { + text: 'SDK e API', + collapsed: true, + home: true, + items: [ + { text: 'Visão geral do SDK', link: '/pt/sdk/' }, + { text: 'Java SDK', link: '/pt/sdk/java' }, + { text: 'Python SDK', link: '/pt/sdk/python' }, + { text: 'JavaScript SDK', link: '/pt/sdk/js' }, + { text: 'Outros SDK', link: '/pt/sdk/other' }, + ] + } +] \ No newline at end of file diff --git a/docs/pt/trademark/images/logo-black-bg.svg b/docs/pt/trademark/images/logo-black-bg.svg new file mode 100644 index 0000000..9b67231 --- /dev/null +++ b/docs/pt/trademark/images/logo-black-bg.svg @@ -0,0 +1,13 @@ + + + logo 2备份 + + + + + + + + + + \ No newline at end of file diff --git a/docs/pt/trademark/images/logo-gray-bg.svg b/docs/pt/trademark/images/logo-gray-bg.svg new file mode 100644 index 0000000..15a19ac --- /dev/null +++ b/docs/pt/trademark/images/logo-gray-bg.svg @@ -0,0 +1,13 @@ + + + logo 2备份 2 + + + + + + + + + + \ No newline at end of file diff --git a/docs/pt/trademark/images/logo-pink-bg.svg b/docs/pt/trademark/images/logo-pink-bg.svg new file mode 100644 index 0000000..4524cb6 --- /dev/null +++ b/docs/pt/trademark/images/logo-pink-bg.svg @@ -0,0 +1,13 @@ + + + logo 2备份 3 + + + + + + + + + + \ No newline at end of file diff --git a/docs/pt/trademark/images/logo-white-bg.svg b/docs/pt/trademark/images/logo-white-bg.svg new file mode 100644 index 0000000..02b5d0a --- /dev/null +++ b/docs/pt/trademark/images/logo-white-bg.svg @@ -0,0 +1,11 @@ + + + logo 2 + + + + + + + + \ No newline at end of file diff --git a/docs/pt/trademark/images/trademark-guidelines.svg b/docs/pt/trademark/images/trademark-guidelines.svg new file mode 100644 index 0000000..0600e37 --- /dev/null +++ b/docs/pt/trademark/images/trademark-guidelines.svg @@ -0,0 +1,65 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + RustFS 官方配色 + 我们的二次色彩可用于增加布局的趣味性。这些颜色 + + 的色调或色调是允许的。 + rustfs.com/html/trademark.html + + diff --git a/docs/pt/trademark/index.md b/docs/pt/trademark/index.md new file mode 100644 index 0000000..7a391bc --- /dev/null +++ b/docs/pt/trademark/index.md @@ -0,0 +1,91 @@ +--- +title: "Descarregar e utilizar marcas" +description: "Diretrizes de uso da marca RustFS e ligação para descarregar logótipos" +--- + +# Descarregar e utilizar marcas + +Todas as imagens desta página destinam‑se apenas a representar o RustFS em diagramas de arquitetura de produto ou listas de suporte. Ao usar, indique a fonte como o site oficial do RustFS. As imagens podem ser redimensionadas proporcionalmente, mas não podem ser modificadas por outros meios. + +RustFS® e rustfs logo® são marcas registadas da Beijing Hengheshake Technology Co., Ltd. na China. Sem consentimento escrito do RustFS, não é permitida a utilização destas imagens para outros fins. + +Para outras questões, contacte‑nos por e‑mail: . + +## Logótipo RustFS + +### Versão para fundo branco + +![RustFS Logo - fundo branco](./images/logo-white-bg.svg) + +### Versões para diferentes fundos + +| Fundo preto | Fundo cinzento | Fundo rosa | +|----------|----------|----------| +| ![RustFS Logo - fundo preto](./images/logo-black-bg.svg) | ![RustFS Logo - fundo cinzento](./images/logo-gray-bg.svg) | ![RustFS Logo - fundo rosa](./images/logo-pink-bg.svg) | + +### Ligações de download + +🔗 [Descarregar tudo](https://rustfs.com/images/trademark/logo.zip) + +## Diretrizes de uso da marca + +![Diretrizes de marca](./images/trademark-guidelines.svg) + +## Documento de diretrizes + +### Versão + +v1.0 + +### Introdução + +O RustFS é um sistema de armazenamento de objetos distribuído e de alto desempenho. É software definido, corre em hardware padrão de mercado e é 100% open source sob a licença Apache Version 2.0. + +Este documento resume a política de uso de marca do projeto RustFS. Qualquer utilização das marcas RustFS deve cumprir esta política. “Marca” inclui marcas verbais, marcas de serviço, logótipos, trade dress, nomes de produtos, serviços, negócio e empresa do RustFS. + +As marcas RustFS incluem RustFS e produtos derivados. + +Como comunidade open source, encorajamos a utilização e melhoria alargada do nosso código, distribuído sob licenças abertas. Ainda assim, é crucial garantir que as marcas RustFS permaneçam um indicador fiável de qualidade e origem e proteger utilizadores contra fraude. Assim, embora haja ampla liberdade para redistribuir/modificar código, a lei de marcas e esta política devem ser cumpridas. + +### Diretrizes gerais + +- O uso deve evitar causar confusão quanto a oficialidade/apoio do RustFS +- Sites/software não oficiais não devem sugerir aprovação/afiliação +- Em caso de dúvida, contacte: + +### O que pode fazer + +- Redistribuir binários oficiais não modificados de , respeitando leis/licenças. Não remova/altere marcas. Pode declarar veridicamente que fornece RustFS não modificado +- Usar marcas em materiais de marketing/divulgação sem causar confusão +- Serviços relacionados: pode referenciar marcas ao descrever/ promover serviços, sem violar diretrizes gerais ou sugerir relação direta +- Logótipos/merchandising: pode produzir itens para si/próximos (sem contrapartida comercial) +- Referenciar/ligar honestamente a programas/produtos/serviços/tecnologias RustFS não modificados + +### O que não pode fazer + +1. Colocar o logótipo RustFS em produtos de produção comercial +2. Modificar, abreviar, combinar com outros símbolos/texto/imagens ou incorporar em slogans +3. Criar versões modificadas do logótipo RustFS para qualquer fim +4. Usar marcas de modo a sugerir afiliação, patrocínio, endosso ou aprovação indevida +5. Usar marcas para fins comerciais, salvo uso meramente descritivo/verdadeiro +6. Usar marcas em nomes/handles de redes sociais + +É permitido modificar o software sob licenças open source, mas não redistribuir versões modificadas com marcas RustFS. Em vez de “baseado em RustFS”, use “baseado na tecnologia RustFS” ou “contém código‑fonte RustFS”. Altere nomes de produto/binários para evitar confusão com o RustFS original. + +### Autorizações necessárias + +- Ícones de website: requerem autorização prévia +- Domínios: incluir as marcas (total/parcial) num domínio exige autorização por escrito; tal uso pode causar confusão + +### Como usar as marcas + +1. Forma correta — usar a marca tal como é (sem abreviações/combinações) +2. Símbolos — na primeira ou mais proeminente menção, indicar ® ou ™ conforme aplicável +3. Atribuição — incluir a indicação “[Marca] é marca [registada, se aplicável] da RustFS” +4. Distinção — a marca deve destacar‑se do texto (maiúsculas, itálico, negrito ou sublinhado) + +Não altere o logótipo exceto escala. Não adicione ornamentos, mude cores, proporções, distorça, adicione elementos ou combine com outros logótipos. Em contextos a preto‑e‑branco, pode reproduzir o logótipo em P&B. + +### Questões + +Se considerar um uso não coberto por esta política, contacte . O RustFS pode revogar autorizações a qualquer momento em caso de violação, exigindo a cessação imediata do uso. Esta política pode ser atualizada; consulte esta página para atualizações.