> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Replicação + escalonamento

> Ao acompanhar este tutorial, você aprenderá a configurar um cluster ClickHouse simples.

export const Image = ({img, alt, size = "lg"}) => {
  const normalizedSize = ["sm", "md", "lg"].includes(size) ? size : "lg";
  return <div className={`ch-image-${normalizedSize}`}>
      <Frame>
        <img src={img} alt={alt} />
      </Frame>
    </div>;
};

> Neste exemplo, você aprenderá a configurar um cluster ClickHouse simples que
> oferece replicação e escalabilidade. Ele consiste em dois shards e duas réplicas, com um
> cluster ClickHouse Keeper de 3 nós para gerenciar a coordenação e manter o quórum
> no cluster.

A arquitetura do cluster que você configurará é mostrada abaixo:

<Image img="https://mintcdn.com/private-7c7dfe99/NvnCM4vX9aZ07JxK/images/deployment-guides/replication-sharding-examples/both.webp?fit=max&auto=format&n=NvnCM4vX9aZ07JxK&q=85&s=444ba6cf62f0cd793a61a70b98468d6c" size="md" alt="Diagrama de arquitetura para 2 shards e 1 réplica" width="1200" height="800" data-path="images/deployment-guides/replication-sharding-examples/both.webp" />

<Note>
  Embora seja possível executar o ClickHouse Server e o ClickHouse Keeper juntos no mesmo servidor,
  recomendamos fortemente usar hosts *dedicados* para o ClickHouse Keeper em ambientes de produção,
  e essa é a abordagem que demonstraremos neste exemplo.

  Os servidores do Keeper podem ser menores, e 4 GB de RAM geralmente bastam para cada servidor do Keeper
  até que seus servidores ClickHouse atinjam grande porte.
</Note>

<div id="prerequisites">
  ## Pré-requisitos
</div>

* Você já configurou anteriormente um [servidor ClickHouse local](/docs/pt-BR/get-started/setup/install)
* Você está familiarizado com conceitos básicos de configuração do ClickHouse, como [arquivos de configuração](/docs/pt-BR/concepts/features/configuration/server-config/configuration-files)
* Você tem o Docker instalado na sua máquina

<Steps>
  <Step title="Configurar a estrutura de diretórios e o ambiente de teste" id="set-up">
    <Tip>
      **Arquivos de exemplo**

      As etapas a seguir vão orientar você na configuração do cluster do
      zero. Se preferir pular essas etapas e ir direto para executar o
      cluster, você pode obter os arquivos de
      exemplo no repositório de exemplos, no [diretório 'docker-compose-recipes'](https://github.com/ClickHouse/examples/tree/main/docker-compose-recipes/recipes).
    </Tip>

    Neste tutorial, você usará o [Docker compose](https://docs.docker.com/compose/) para
    configurar o cluster do ClickHouse. Esta configuração pode ser adaptada para funcionar
    em máquinas locais separadas, máquinas virtuais ou instâncias de nuvem também.

    Execute os seguintes comandos para configurar a estrutura de diretórios deste exemplo:

    ```bash theme={null}
    mkdir cluster_2S_2R
    cd cluster_2S_2R

    # Create clickhouse-keeper directories
    for i in {01..03}; do
      mkdir -p fs/volumes/clickhouse-keeper-${i}/etc/clickhouse-keeper
    done

    # Create clickhouse-server directories
    for i in {01..04}; do
      mkdir -p fs/volumes/clickhouse-${i}/etc/clickhouse-server
    done
    ```

    Adicione o seguinte arquivo `docker-compose.yml` ao diretório `clickhouse-cluster`:

    ```yaml title="docker-compose.yml" theme={null}
    version: '3.8'
    services:
      clickhouse-01:
        image: "clickhouse/clickhouse-server:latest"
        user: "101:101"
        container_name: clickhouse-01
        hostname: clickhouse-01
        volumes:
          - ${PWD}/fs/volumes/clickhouse-01/etc/clickhouse-server/config.d/config.xml:/etc/clickhouse-server/config.d/config.xml
          - ${PWD}/fs/volumes/clickhouse-01/etc/clickhouse-server/users.d/users.xml:/etc/clickhouse-server/users.d/users.xml
        ports:
          - "127.0.0.1:8123:8123"
          - "127.0.0.1:9000:9000"
        depends_on:
          - clickhouse-keeper-01
          - clickhouse-keeper-02
          - clickhouse-keeper-03
      clickhouse-02:
        image: "clickhouse/clickhouse-server:latest"
        user: "101:101"
        container_name: clickhouse-02
        hostname: clickhouse-02
        volumes:
          - ${PWD}/fs/volumes/clickhouse-02/etc/clickhouse-server/config.d/config.xml:/etc/clickhouse-server/config.d/config.xml
          - ${PWD}/fs/volumes/clickhouse-02/etc/clickhouse-server/users.d/users.xml:/etc/clickhouse-server/users.d/users.xml
        ports:
          - "127.0.0.1:8124:8123"
          - "127.0.0.1:9001:9000"
        depends_on:
          - clickhouse-keeper-01
          - clickhouse-keeper-02
          - clickhouse-keeper-03
      clickhouse-03:
        image: "clickhouse/clickhouse-server:latest"
        user: "101:101"
        container_name: clickhouse-03
        hostname: clickhouse-03
        volumes:
          - ${PWD}/fs/volumes/clickhouse-03/etc/clickhouse-server/config.d/config.xml:/etc/clickhouse-server/config.d/config.xml
          - ${PWD}/fs/volumes/clickhouse-03/etc/clickhouse-server/users.d/users.xml:/etc/clickhouse-server/users.d/users.xml
        ports:
          - "127.0.0.1:8125:8123"
          - "127.0.0.1:9002:9000"
        depends_on:
          - clickhouse-keeper-01
          - clickhouse-keeper-02
          - clickhouse-keeper-03
      clickhouse-04:
        image: "clickhouse/clickhouse-server:latest"
        user: "101:101"
        container_name: clickhouse-04
        hostname: clickhouse-04
        volumes:
          - ${PWD}/fs/volumes/clickhouse-04/etc/clickhouse-server/config.d/config.xml:/etc/clickhouse-server/config.d/config.xml
          - ${PWD}/fs/volumes/clickhouse-04/etc/clickhouse-server/users.d/users.xml:/etc/clickhouse-server/users.d/users.xml
        ports:
          - "127.0.0.1:8126:8123"
          - "127.0.0.1:9003:9000"
        depends_on:
          - clickhouse-keeper-01
          - clickhouse-keeper-02
          - clickhouse-keeper-03
      clickhouse-keeper-01:
        image: "clickhouse/clickhouse-keeper:latest-alpine"
        user: "101:101"
        container_name: clickhouse-keeper-01
        hostname: clickhouse-keeper-01
        volumes:
          - ${PWD}/fs/volumes/clickhouse-keeper-01/etc/clickhouse-keeper/keeper_config.xml:/etc/clickhouse-keeper/keeper_config.xml
        ports:
          - "127.0.0.1:9181:9181"
      clickhouse-keeper-02:
        image: "clickhouse/clickhouse-keeper:latest-alpine"
        user: "101:101"
        container_name: clickhouse-keeper-02
        hostname: clickhouse-keeper-02
        volumes:
          - ${PWD}/fs/volumes/clickhouse-keeper-02/etc/clickhouse-keeper/keeper_config.xml:/etc/clickhouse-keeper/keeper_config.xml
        ports:
          - "127.0.0.1:9182:9181"
      clickhouse-keeper-03:
        image: "clickhouse/clickhouse-keeper:latest-alpine"
        user: "101:101"
        container_name: clickhouse-keeper-03
        hostname: clickhouse-keeper-03
        volumes:
          - ${PWD}/fs/volumes/clickhouse-keeper-03/etc/clickhouse-keeper/keeper_config.xml:/etc/clickhouse-keeper/keeper_config.xml
        ports:
          - "127.0.0.1:9183:9181"
    ```

    Crie os seguintes subdiretórios e arquivos:

    ```bash theme={null}
    for i in {01..04}; do
      mkdir -p fs/volumes/clickhouse-${i}/etc/clickhouse-server/config.d
      mkdir -p fs/volumes/clickhouse-${i}/etc/clickhouse-server/users.d
      touch fs/volumes/clickhouse-${i}/etc/clickhouse-server/config.d/config.xml
      touch fs/volumes/clickhouse-${i}/etc/clickhouse-server/users.d/users.xml
    done
    ```

    * O diretório `config.d` contém o arquivo de configuração do servidor ClickHouse `config.xml`,
      no qual é definida a configuração personalizada de cada nó do ClickHouse. Essa
      configuração é combinada com o arquivo de configuração padrão `config.xml` do ClickHouse,
      incluído em toda instalação do ClickHouse.
    * O diretório `users.d` contém o arquivo de configuração de usuários `users.xml`, no qual
      é definida a configuração personalizada dos usuários. Essa configuração é combinada com
      o arquivo de configuração padrão `users.xml` do ClickHouse, incluído em toda
      instalação do ClickHouse.

    <Tip>
      **Diretórios de configuração personalizados**

      É uma prática recomendada usar os diretórios `config.d` e `users.d` ao
      criar sua própria configuração, em vez de modificar diretamente a configuração padrão
      em `/etc/clickhouse-server/config.xml` e `etc/clickhouse-server/users.xml`.

      A linha

      ```xml theme={null}
      <clickhouse replace="true">
      ```

      garante que as seções de configuração definidas nos diretórios `config.d` e `users.d`
      substituam as seções de configuração padrão definidas nos arquivos padrão
      `config.xml` e `users.xml`.
    </Tip>
  </Step>

  <Step title="Configurar nós do ClickHouse" id="configure-clickhouse-servers">
    ### Configuração do servidor

    Agora modifique cada arquivo de configuração vazio `config.xml` localizado em
    `fs/volumes/clickhouse-{}/etc/clickhouse-server/config.d`. As linhas que estão
    destacadas abaixo precisam ser alteradas para serem específicas a cada nó:

    ```xml highlight={9,64-67} theme={null}
    <clickhouse replace="true">
        <logger>
            <level>debug</level>
            <log>/var/log/clickhouse-server/clickhouse-server.log</log>
            <errorlog>/var/log/clickhouse-server/clickhouse-server.err.log</errorlog>
            <size>1000M</size>
            <count>3</count>
        </logger>
        <display_name>cluster_2S_2R node 1</display_name>
        <listen_host>0.0.0.0</listen_host>
        <http_port>8123</http_port>
        <tcp_port>9000</tcp_port>
        <user_directories>
            <users_xml>
                <path>users.xml</path>
            </users_xml>
            <local_directory>
                <path>/var/lib/clickhouse/access/</path>
            </local_directory>
        </user_directories>
        <distributed_ddl>
            <path>/clickhouse/task_queue/ddl</path>
        </distributed_ddl>
        <remote_servers>
            <cluster_2S_2R>
                <shard>
                    <internal_replication>true</internal_replication>
                    <replica>
                        <host>clickhouse-01</host>
                        <port>9000</port>
                    </replica>
                    <replica>
                        <host>clickhouse-03</host>
                        <port>9000</port>
                    </replica>
                </shard>
                <shard>
                    <internal_replication>true</internal_replication>
                    <replica>
                        <host>clickhouse-02</host>
                        <port>9000</port>
                    </replica>
                    <replica>
                        <host>clickhouse-04</host>
                        <port>9000</port>
                    </replica>
                </shard>
            </cluster_2S_2R>
        </remote_servers>
        <zookeeper>
            <node>
                <host>clickhouse-keeper-01</host>
                <port>9181</port>
            </node>
            <node>
                <host>clickhouse-keeper-02</host>
                <port>9181</port>
            </node>
            <node>
                <host>clickhouse-keeper-03</host>
                <port>9181</port>
            </node>
        </zookeeper>
        <macros>
            <shard>01</shard>
            <replica>01</replica>
        </macros>
    </clickhouse>
    ```

    | Diretório                                                 | File                                                                                                                                                                             |
    | --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `fs/volumes/clickhouse-01/etc/clickhouse-server/config.d` | [`config.xml`](https://github.com/ClickHouse/examples/blob/main/docker-compose-recipes/recipes/cluster_2S_2R/fs/volumes/clickhouse-01/etc/clickhouse-server/config.d/config.xml) |
    | `fs/volumes/clickhouse-02/etc/clickhouse-server/config.d` | [`config.xml`](https://github.com/ClickHouse/examples/blob/main/docker-compose-recipes/recipes/cluster_2S_2R/fs/volumes/clickhouse-02/etc/clickhouse-server/config.d/config.xml) |
    | `fs/volumes/clickhouse-03/etc/clickhouse-server/config.d` | [`config.xml`](https://github.com/ClickHouse/examples/blob/main/docker-compose-recipes/recipes/cluster_2S_2R/fs/volumes/clickhouse-03/etc/clickhouse-server/config.d/config.xml) |
    | `fs/volumes/clickhouse-04/etc/clickhouse-server/config.d` | [`config.xml`](https://github.com/ClickHouse/examples/blob/main/docker-compose-recipes/recipes/cluster_2S_2R/fs/volumes/clickhouse-04/etc/clickhouse-server/config.d/config.xml) |

    Cada seção do arquivo de configuração acima é explicada com mais detalhes a seguir.

    #### Rede e logging

    A comunicação externa pela interface de rede é habilitada ao ativar a configuração
    listen\_host. Isso garante que o host do servidor ClickHouse possa ser acessado por outros
    hosts:

    ```xml theme={null}
    <listen_host>0.0.0.0</listen_host>
    ```

    A porta da API HTTP está configurada como `8123`:

    ```xml theme={null}
    <http_port>8123</http_port>
    ```

    A porta TCP usada para comunicação pelo protocolo nativo do ClickHouse entre clickhouse-client
    e outras ferramentas nativas do ClickHouse, e entre clickhouse-server e outros clickhouse-servers
    é definida como `9000`:

    ```xml theme={null}
    <tcp_port>9000</tcp_port>
    ```

    A configuração de logging é definida no bloco `<logger>`. Esta configuração de exemplo
    gera um log de depuração que será rotacionado em 1000M três vezes:

    ```xml theme={null}
    <logger>
       <level>debug</level>
       <log>/var/log/clickhouse-server/clickhouse-server.log</log>
       <errorlog>/var/log/clickhouse-server/clickhouse-server.err.log</errorlog>
       <size>1000M</size>
       <count>3</count>
    </logger>
    ```

    Para mais informações sobre a configuração de logging, consulte os comentários incluídos no
    [arquivo de configuração](https://github.com/ClickHouse/ClickHouse/blob/master/programs/server/config.xml) padrão do ClickHouse.

    #### Configuração do cluster

    A configuração do cluster é definida no bloco `<remote_servers>`.
    Aqui é definido o nome do cluster `cluster_2S_2R`.

    O bloco `<cluster_2S_2R></cluster_2S_2R>` define o layout do cluster,
    utilizando as configurações `<shard></shard>` e `<replica></replica>`, e serve como
    template para consultas de DDL distribuído, que são queries executadas em todo o
    cluster por meio da cláusula `ON CLUSTER`. Por padrão, as consultas de DDL distribuído
    são permitidas, mas também podem ser desativadas com a configuração `allow_distributed_ddl_queries`.

    `internal_replication` está definido como true para que os dados sejam gravados em apenas uma das réplicas.

    ```xml theme={null}
    <remote_servers>
       <!-- cluster name (should not contain dots) -->
      <cluster_2S_2R>
          <!-- <allow_distributed_ddl_queries>false</allow_distributed_ddl_queries> -->
          <shard>
              <!-- Optional. Whether to write data to just one of the replicas. Default: false (write data to all replicas). -->
              <internal_replication>true</internal_replication>
              <replica>
                  <host>clickhouse-01</host>
                  <port>9000</port>
              </replica>
              <replica>
                  <host>clickhouse-03</host>
                  <port>9000</port>
              </replica>
          </shard>
          <shard>
              <internal_replication>true</internal_replication>
              <replica>
                  <host>clickhouse-02</host>
                  <port>9000</port>
              </replica>
              <replica>
                  <host>clickhouse-04</host>
                  <port>9000</port>
              </replica>
          </shard>
      </cluster_2S_2R>
    </remote_servers>
    ```

    A seção `<cluster_2S_2R></cluster_2S_2R>` define o layout do cluster
    e serve como template para queries de DDL distribuído, que são queries executadas
    em todo o cluster usando a cláusula `ON CLUSTER`.

    #### Configuração do Keeper

    A seção `<ZooKeeper>` informa ao ClickHouse onde o ClickHouse Keeper (ou ZooKeeper) está em execução.
    Como estamos usando um cluster do ClickHouse Keeper, cada `<node>` do cluster precisa ser especificado,
    junto com seu hostname e número de porta, por meio das tags `<host>` e `<port>`, respectivamente.

    A configuração do ClickHouse Keeper é explicada na próxima etapa do tutorial.

    ```xml theme={null}
    <zookeeper>
        <node>
            <host>clickhouse-keeper-01</host>
            <port>9181</port>
        </node>
        <node>
            <host>clickhouse-keeper-02</host>
            <port>9181</port>
        </node>
        <node>
            <host>clickhouse-keeper-03</host>
            <port>9181</port>
        </node>
    </zookeeper>
    ```

    <Note>
      Embora seja possível executar o ClickHouse Keeper no mesmo servidor que o ClickHouse Server,
      em ambientes de produção, recomendamos fortemente que o ClickHouse Keeper seja executado em servidores dedicados.
    </Note>

    #### Configuração de macros

    Além disso, a seção `<macros>` é usada para definir substituições de parâmetros para
    tabelas replicadas. Elas são listadas em `system.macros` e permitem o uso de substituições
    como `{shard}` e `{replica}` em queries.

    ```xml theme={null}
    <macros>
       <shard>01</shard>
       <replica>01</replica>
    </macros>
    ```

    ### Configuração de usuário

    Agora modifique cada arquivo de configuração vazio `users.xml` localizado em
    `fs/volumes/clickhouse-{}/etc/clickhouse-server/users.d` com o seguinte conteúdo:

    ```xml title="/users.d/users.xml" theme={null}
    <?xml version="1.0"?>
    <clickhouse replace="true">
        <profiles>
            <default>
                <max_memory_usage>10000000000</max_memory_usage>
                <use_uncompressed_cache>0</use_uncompressed_cache>
                <load_balancing>in_order</load_balancing>
                <log_queries>1</log_queries>
            </default>
        </profiles>
        <users>
            <default>
                <access_management>1</access_management>
                <profile>default</profile>
                <networks>
                    <ip>::/0</ip>
                </networks>
                <quota>default</quota>
                <access_management>1</access_management>
                <named_collection_control>1</named_collection_control>
                <show_named_collections>1</show_named_collections>
                <show_named_collections_secrets>1</show_named_collections_secrets>
            </default>
        </users>
        <quotas>
            <default>
                <interval>
                    <duration>3600</duration>
                    <queries>0</queries>
                    <errors>0</errors>
                    <result_rows>0</result_rows>
                    <read_rows>0</read_rows>
                    <execution_time>0</execution_time>
                </interval>
            </default>
        </quotas>
    </clickhouse>
    ```

    Neste exemplo, o usuário padrão é configurado sem senha para simplificar.
    Na prática, isso não é recomendado.

    <Note>
      Neste exemplo, o arquivo `users.xml` é idêntico em todos os nós do cluster.
    </Note>
  </Step>

  <Step title="Configurar o ClickHouse Keeper" id="configure-clickhouse-keeper-nodes">
    Em seguida, você vai configurar o ClickHouse Keeper, que é usado para coordenação.

    ### Configuração do Keeper

    Para que a replicação funcione, é necessário configurar e
    implantar um cluster do ClickHouse Keeper. O ClickHouse Keeper fornece o sistema de coordenação para a replicação de dados,
    atuando como um substituto direto do ZooKeeper, que também pode ser usado.
    No entanto, o ClickHouse Keeper é recomendado, pois oferece melhores garantias e
    confiabilidade, além de usar menos recursos do que o ZooKeeper. Para alta disponibilidade e para
    manter o quórum, recomenda-se executar pelo menos três nós do ClickHouse Keeper.

    <Note>
      O ClickHouse Keeper pode ser executado em qualquer nó do cluster junto com o ClickHouse, embora
      seja recomendável executá-lo em um nó dedicado, o que permite escalar e
      gerenciar o cluster do ClickHouse Keeper independentemente do cluster do banco de dados.
    </Note>

    Crie os arquivos `keeper_config.xml` para cada nó do ClickHouse Keeper
    usando o comando abaixo a partir da raiz da pasta de exemplo:

    ```bash theme={null}
    for i in {01..03}; do
      touch fs/volumes/clickhouse-keeper-${i}/etc/clickhouse-keeper/keeper_config.xml
    done
    ```

    Modifique os arquivos de configuração vazios criados em cada
    diretório de nó `fs/volumes/clickhouse-keeper-{}/etc/clickhouse-keeper`. As
    linhas destacadas abaixo precisam ser ajustadas para cada nó:

    ```xml title="/clickhouse-keeper/keeper_config.xml" highlight={12} theme={null}
    <clickhouse replace="true">
        <logger>
            <level>information</level>
            <log>/var/log/clickhouse-keeper/clickhouse-keeper.log</log>
            <errorlog>/var/log/clickhouse-keeper/clickhouse-keeper.err.log</errorlog>
            <size>1000M</size>
            <count>3</count>
        </logger>
        <listen_host>0.0.0.0</listen_host>
        <keeper_server>
            <tcp_port>9181</tcp_port>
            <server_id>1</server_id>
            <log_storage_path>/var/lib/clickhouse/coordination/log</log_storage_path>
            <snapshot_storage_path>/var/lib/clickhouse/coordination/snapshots</snapshot_storage_path>
            <coordination_settings>
                <operation_timeout_ms>10000</operation_timeout_ms>
                <session_timeout_ms>30000</session_timeout_ms>
                <raft_logs_level>information</raft_logs_level>
            </coordination_settings>
            <raft_configuration>
                <server>
                    <id>1</id>
                    <hostname>clickhouse-keeper-01</hostname>
                    <port>9234</port>
                </server>
                <server>
                    <id>2</id>
                    <hostname>clickhouse-keeper-02</hostname>
                    <port>9234</port>
                </server>
                <server>
                    <id>3</id>
                    <hostname>clickhouse-keeper-03</hostname>
                    <port>9234</port>
                </server>
            </raft_configuration>
        </keeper_server>
    </clickhouse>
    ```

    | Diretório                                               | Arquivo                                                                                                                                                                                      |
    | ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `fs/volumes/clickhouse-keeper-01/etc/clickhouse-keeper` | [`keeper_config.xml`](https://github.com/ClickHouse/examples/blob/main/docker-compose-recipes/recipes/cluster_2S_2R/fs/volumes/clickhouse-keeper-01/etc/clickhouse-keeper/keeper_config.xml) |
    | `fs/volumes/clickhouse-keeper-02/etc/clickhouse-keeper` | [`keeper_config.xml`](https://github.com/ClickHouse/examples/blob/main/docker-compose-recipes/recipes/cluster_2S_2R/fs/volumes/clickhouse-keeper-02/etc/clickhouse-keeper/keeper_config.xml) |
    | `fs/volumes/clickhouse-keeper-03/etc/clickhouse-keeper` | [`keeper_config.xml`](https://github.com/ClickHouse/examples/blob/main/docker-compose-recipes/recipes/cluster_2S_2R/fs/volumes/clickhouse-keeper-03/etc/clickhouse-keeper/keeper_config.xml) |

    Cada arquivo de configuração conterá a seguinte configuração exclusiva (mostrada abaixo).
    O `server_id` usado deve ser exclusivo para esse nó específico do ClickHouse Keeper
    no cluster e corresponder ao `<id>` do servidor definido na seção `<raft_configuration>`.
    `tcp_port` é a porta usada pelos *clientes* do ClickHouse Keeper.

    ```xml theme={null}
    <tcp_port>9181</tcp_port>
    <server_id>{id}</server_id>
    ```

    A seção a seguir é usada para configurar os servidores que participam do
    quórum do [algoritmo de consenso Raft](https://en.wikipedia.org/wiki/Raft_\(algorithm\)):

    ```xml highlight={6} theme={null}
    <raft_configuration>
        <server>
            <id>1</id>
            <hostname>clickhouse-keeper-01</hostname>
            <!-- Porta TCP usada para comunicação entre os nós do ClickHouse Keeper -->
            <port>9234</port>
        </server>
        <server>
            <id>2</id>
            <hostname>clickhouse-keeper-02</hostname>
            <port>9234</port>
        </server>
        <server>
            <id>3</id>
            <hostname>clickhouse-keeper-03</hostname>
            <port>9234</port>
        </server>
    </raft_configuration>
    ```

    <Tip>
      **ClickHouse Cloud simplifica o gerenciamento**

      [ClickHouse Cloud](/docs/pt-BR/products/cloud/getting-started/intro)
      elimina a carga operacional associada ao gerenciamento de shards e réplicas. A
      plataforma cuida automaticamente da alta disponibilidade, da replicação e do escalonamento.
      Compute e armazenamento são separados e escalam conforme a demanda, sem exigir
      configuração manual nem manutenção contínua.

      [Leia mais](/docs/pt-BR/products/cloud/features/autoscaling/overview)
    </Tip>
  </Step>

  <Step title="Teste a configuração" id="test-the-setup">
    Verifique se o Docker está em execução na sua máquina.
    Inicie o cluster com o comando `docker-compose up` a partir da raiz do diretório `cluster_2S_2R`:

    ```bash theme={null}
    docker-compose up -d
    ```

    Você deverá ver o Docker começar a baixar as imagens do ClickHouse e do Keeper,
    e depois iniciar os contêineres:

    ```bash theme={null}
    [+] Running 8/8
     ✔ Network   cluster_2s_2r_default     Created
     ✔ Container clickhouse-keeper-03      Started
     ✔ Container clickhouse-keeper-02      Started
     ✔ Container clickhouse-keeper-01      Started
     ✔ Container clickhouse-01             Started
     ✔ Container clickhouse-02             Started
     ✔ Container clickhouse-04             Started
     ✔ Container clickhouse-03             Started
    ```

    Para verificar se o cluster está em execução, conecte-se a qualquer um dos nós e execute a
    consulta a seguir. O comando para se conectar ao primeiro nó é o seguinte:

    ```bash theme={null}
    # Connect to any node
    docker exec -it clickhouse-01 clickhouse-client
    ```

    Se tudo ocorrer conforme esperado, você verá o prompt do ClickHouse client:

    ```response theme={null}
    cluster_2S_2R node 1 :)
    ```

    Execute a seguinte consulta para verificar quais topologias de cluster estão definidas em quais
    hosts:

    ```sql title="Query" theme={null}
    SELECT 
        cluster,
        shard_num,
        replica_num,
        host_name,
        port
    FROM system.clusters;
    ```

    ```response title="Response" theme={null}
       ┌─cluster───────┬─shard_num─┬─replica_num─┬─host_name─────┬─port─┐
    1. │ cluster_2S_2R │         1 │           1 │ clickhouse-01 │ 9000 │
    2. │ cluster_2S_2R │         1 │           2 │ clickhouse-03 │ 9000 │
    3. │ cluster_2S_2R │         2 │           1 │ clickhouse-02 │ 9000 │
    4. │ cluster_2S_2R │         2 │           2 │ clickhouse-04 │ 9000 │
    5. │ default       │         1 │           1 │ localhost     │ 9000 │
       └───────────────┴───────────┴─────────────┴───────────────┴──────┘
    ```

    Execute a seguinte consulta para verificar o status do cluster do ClickHouse Keeper:

    ```sql title="Query" theme={null}
    SELECT *
    FROM system.zookeeper
    WHERE path IN ('/', '/clickhouse')
    ```

    ```response title="Response" theme={null}
       ┌─name───────┬─value─┬─path────────┐
    1. │ task_queue │       │ /clickhouse │
    2. │ sessions   │       │ /clickhouse │
    3. │ keeper     │       │ /           │
    4. │ clickhouse │       │ /           │
       └────────────┴───────┴─────────────┘
    ```

    O comando `mntr` também é comumente usado para verificar se o ClickHouse Keeper está
    em execução e para obter informações de estado sobre a relação entre os três nós do Keeper.
    Na configuração usada neste exemplo, há três nós trabalhando juntos.
    Os nós elegerão um líder, e os nós restantes serão seguidores.

    O comando `mntr` fornece informações relacionadas ao desempenho e indica se um determinado
    nó é seguidor ou líder.

    <Tip>
      Talvez seja necessário instalar o `netcat` para enviar o comando `mntr` ao Keeper.
      Consulte a página [nmap.org](https://nmap.org/ncat/) para obter informações de download.
    </Tip>

    Execute o comando abaixo em um shell no `clickhouse-keeper-01`, `clickhouse-keeper-02` e
    `clickhouse-keeper-03` para verificar o status de cada nó do Keeper. O comando
    para `clickhouse-keeper-01` é mostrado abaixo:

    ```bash theme={null}
    docker exec -it clickhouse-keeper-01  /bin/sh -c 'echo mntr | nc 127.0.0.1 9181'
    ```

    A resposta abaixo mostra um exemplo de resposta de um nó seguidor:

    ```response title="Response" highlight={9} theme={null}
    zk_version      v23.3.1.2823-testing-46e85357ce2da2a99f56ee83a079e892d7ec3726
    zk_avg_latency  0
    zk_max_latency  0
    zk_min_latency  0
    zk_packets_received     0
    zk_packets_sent 0
    zk_num_alive_connections        0
    zk_outstanding_requests 0
    zk_server_state follower
    zk_znode_count  6
    zk_watch_count  0
    zk_ephemerals_count     0
    zk_approximate_data_size        1271
    zk_key_arena_size       4096
    zk_latest_snapshot_size 0
    zk_open_file_descriptor_count   46
    zk_max_file_descriptor_count    18446744073709551615
    ```

    A resposta abaixo mostra um exemplo de resposta de um nó líder:

    ```response title="Response" highlight={9,18-19} theme={null}
    zk_version      v23.3.1.2823-testing-46e85357ce2da2a99f56ee83a079e892d7ec3726
    zk_avg_latency  0
    zk_max_latency  0
    zk_min_latency  0
    zk_packets_received     0
    zk_packets_sent 0
    zk_num_alive_connections        0
    zk_outstanding_requests 0
    zk_server_state leader
    zk_znode_count  6
    zk_watch_count  0
    zk_ephemerals_count     0
    zk_approximate_data_size        1271
    zk_key_arena_size       4096
    zk_latest_snapshot_size 0
    zk_open_file_descriptor_count   48
    zk_max_file_descriptor_count    18446744073709551615
    zk_followers    2
    zk_synced_followers     2
    ```

    Com isso, você configurou com sucesso um cluster do ClickHouse com dois shards e duas réplicas.
    Na próxima etapa, você criará uma tabela no cluster.
  </Step>

  <Step title="Criar um banco de dados" id="creating-a-database">
    Agora que você verificou que o cluster está configurado corretamente e em execução,
    você recriará a mesma tabela usada no tutorial do conjunto de dados de exemplo [preços de imóveis no Reino Unido](/docs/pt-BR/get-started/sample-datasets/uk-price-paid).
    Ela contém cerca de 30 milhões de linhas com os valores pagos
    por imóveis na Inglaterra e no País de Gales desde 1995.

    Conecte-se ao cliente de cada host executando cada um dos comandos a seguir em abas ou janelas
    de terminal separadas:

    ```bash theme={null}
    docker exec -it clickhouse-01 clickhouse-client
    docker exec -it clickhouse-02 clickhouse-client
    docker exec -it clickhouse-03 clickhouse-client
    docker exec -it clickhouse-04 clickhouse-client
    ```

    Você pode executar a consulta abaixo no clickhouse-client de cada host para confirmar que ainda não foi criado nenhum banco de dados,
    além dos bancos de dados padrão:

    ```sql title="Query" theme={null}
    SHOW DATABASES;
    ```

    ```response title="Response" theme={null}
       ┌─name───────────────┐
    1. │ INFORMATION_SCHEMA │
    2. │ default            │
    3. │ information_schema │
    4. │ system             │
       └────────────────────┘
    ```

    No cliente `clickhouse-01`, execute a seguinte **consulta** DDL **distribuída** usando a
    cláusula `ON CLUSTER` para criar um novo banco de dados chamado `uk`:

    ```sql highlight={2} theme={null}
    CREATE DATABASE IF NOT EXISTS uk 
    ON CLUSTER cluster_2S_2R;
    ```

    Você pode executar novamente a mesma consulta de antes a partir do cliente de cada host
    para confirmar que o banco de dados foi criado em todo o cluster, apesar de a
    consulta ter sido executada apenas a partir de `clickhouse-01`:

    ```sql theme={null}
    SHOW DATABASES;
    ```

    ```response highlight={6} theme={null}
       ┌─name───────────────┐
    1. │ INFORMATION_SCHEMA │
    2. │ default            │
    3. │ information_schema │
    4. │ system             │
    5. │ uk                 │
       └────────────────────┘
    ```
  </Step>

  <Step title="Crie uma tabela no cluster" id="creating-a-table">
    Agora que o banco de dados foi criado, você criará uma tabela com replicação.

    Execute a seguinte consulta em qualquer um dos clientes host:

    ```sql highlight={2,19} theme={null}
    CREATE TABLE IF NOT EXISTS uk.uk_price_paid_local
    ON CLUSTER cluster_2S_2R
    (
        price UInt32,
        date Date,
        postcode1 LowCardinality(String),
        postcode2 LowCardinality(String),
        type Enum8('terraced' = 1, 'semi-detached' = 2, 'detached' = 3, 'flat' = 4, 'other' = 0),
        is_new UInt8,
        duration Enum8('freehold' = 1, 'leasehold' = 2, 'unknown' = 0),
        addr1 String,
        addr2 String,
        street LowCardinality(String),
        locality LowCardinality(String),
        town LowCardinality(String),
        district LowCardinality(String),
        county LowCardinality(String)
    )
    ENGINE = ReplicatedMergeTree('/clickhouse/tables/{database}/{table}/{shard}', '{replica}')
    ORDER BY (postcode1, postcode2, addr1, addr2);
    ```

    Observe que ela é idêntica à consulta usada na instrução `CREATE` original do
    tutorial do conjunto de dados de exemplo [preços de imóveis do Reino Unido](/docs/pt-BR/get-started/sample-datasets/uk-price-paid),
    exceto pela cláusula `ON CLUSTER` e pelo uso do motor `ReplicatedMergeTree`.

    A cláusula `ON CLUSTER` foi projetada para a execução distribuída de consultas DDL (Data Definition Language),
    como `CREATE`, `DROP`, `ALTER` e `RENAME`, garantindo que essas
    alterações no esquema sejam aplicadas em todos os nós de um cluster.

    O motor [`ReplicatedMergeTree`](/docs/pt-BR/reference/engines/table-engines/mergetree-family/replication#converting-from-mergetree-to-replicatedmergetree)
    funciona exatamente como o motor de tabela `MergeTree` comum, mas também replica os dados.
    Ele exige a especificação de dois parâmetros:

    * `zoo_path`: O path do Keeper/ZooKeeper para os metadados da tabela.
    * `replica_name`: O nome da réplica da tabela.

    <br />

    O parâmetro `zoo_path` pode ser definido como qualquer valor de sua escolha, embora seja recomendável seguir
    a convenção de usar o prefixo

    ```text theme={null}
    /clickhouse/tables/{shard}/{database}/{table}
    ```

    onde:

    * `{database}` e `{table}` serão substituídos automaticamente.
    * `{shard}` e `{replica}` são macros que foram [definidas](#macros-config-explanation)
      anteriormente no arquivo `config.xml` de cada nó do ClickHouse.

    Você pode executar a consulta abaixo no cliente de cada host para confirmar que a tabela foi criada em todo o cluster:

    ```sql title="Query" theme={null}
    SHOW TABLES IN uk;
    ```

    ```response title="Response" theme={null}
       ┌─name────────────────┐
    1. │ uk_price_paid_local │
       └─────────────────────┘
    ```
  </Step>

  <Step title="Inserir dados em uma tabela distribuída" id="inserting-data-using-distributed">
    Para inserir dados na tabela, `ON CLUSTER` não pode ser usado, pois não
    se aplica a consultas DML (Data Manipulation Language), como `INSERT`, `UPDATE`
    e `DELETE`. Para inserir dados, é necessário usar o motor de tabela
    [`Distributed`](/docs/pt-BR/reference/engines/table-engines/special/distributed).
    Como você viu no [guia](/docs/pt-BR/guides/oss/deployment-and-scaling/examples/2-shards-1-replica) para configurar um cluster com 2 shards e 1 réplica, tabelas distribuídas são tabelas que têm acesso a shards localizados em diferentes
    hosts e são definidas com o motor de tabela `Distributed`.
    A tabela distribuída atua como a interface entre todos os shards do cluster.

    Em qualquer um dos clientes nos hosts, execute a consulta a seguir para criar uma tabela distribuída
    usando a tabela replicada existente que criamos no passo anterior:

    ```sql theme={null}
    CREATE TABLE IF NOT EXISTS uk.uk_price_paid_distributed
    ON CLUSTER cluster_2S_2R
    ENGINE = Distributed('cluster_2S_2R', 'uk', 'uk_price_paid_local', rand());
    ```

    Em cada host, agora você verá as seguintes tabelas no banco de dados `uk`:

    ```response theme={null}
       ┌─name──────────────────────┐
    1. │ uk_price_paid_distributed │
    2. │ uk_price_paid_local       │
       └───────────────────────────┘
    ```

    Os dados podem ser inseridos na tabela `uk_price_paid_distributed` em qualquer um dos
    clientes host usando a seguinte consulta:

    ```sql theme={null}
    INSERT INTO uk.uk_price_paid_distributed
    SELECT
        toUInt32(price_string) AS price,
        parseDateTimeBestEffortUS(time) AS date,
        splitByChar(' ', postcode)[1] AS postcode1,
        splitByChar(' ', postcode)[2] AS postcode2,
        transform(a, ['T', 'S', 'D', 'F', 'O'], ['terraced', 'semi-detached', 'detached', 'flat', 'other']) AS type,
        b = 'Y' AS is_new,
        transform(c, ['F', 'L', 'U'], ['freehold', 'leasehold', 'unknown']) AS duration,
        addr1,
        addr2,
        street,
        locality,
        town,
        district,
        county
    FROM url(
        'http://prod1.publicdata.landregistry.gov.uk.s3-website-eu-west-1.amazonaws.com/pp-complete.csv',
        'CSV',
        'uuid_string String,
        price_string String,
        time String,
        postcode String,
        a String,
        b String,
        c String,
        addr1 String,
        addr2 String,
        street String,
        locality String,
        town String,
        district String,
        county String,
        d String,
        e String'
    ) SETTINGS max_http_get_redirects=10;
    ```

    Execute a seguinte consulta para confirmar que os dados inseridos foram distribuídos de forma uniforme
    entre os nós do nosso cluster:

    ```sql theme={null}
    SELECT count(*)
    FROM uk.uk_price_paid_distributed;

    SELECT count(*) FROM uk.uk_price_paid_local;
    ```

    ```response theme={null}
       ┌──count()─┐
    1. │ 30212555 │ -- 30.21 million
       └──────────┘

       ┌──count()─┐
    1. │ 15105983 │ -- 15.11 million
       └──────────┘
    ```
  </Step>
</Steps>

<div id="conclusion">
  ## Conclusão
</div>

A vantagem desta topologia de cluster com 2 shards e 2 réplicas é que ela oferece escalabilidade e tolerância a falhas.
Os dados são distribuídos entre hosts separados, reduzindo os requisitos de armazenamento e E/S por nó, enquanto as consultas são processadas em paralelo nos dois shards para melhorar o desempenho e a eficiência de memória.
O mais importante é que o cluster pode tolerar a perda de um nó e continuar atendendo consultas sem interrupção, já que cada shard tem uma réplica de backup disponível em outro nó.

A principal desvantagem desta topologia de cluster é o aumento da sobrecarga de armazenamento — ela exige o dobro da capacidade de armazenamento em comparação com uma configuração sem réplicas, já que cada shard é duplicado.
Além disso, embora o cluster possa suportar a falha de um único nó, a perda simultânea de dois nós pode torná-lo inoperante, dependendo de quais nós falhem e de como os shards estejam distribuídos.
Essa topologia equilibra disponibilidade e custo, tornando-a adequada para ambientes de produção em que algum nível de tolerância a falhas é necessário sem o custo de fatores de replicação mais altos.

Para saber como o ClickHouse Cloud processa consultas, oferecendo escalabilidade e tolerância a falhas, consulte a seção ["Parallel Replicas"](/docs/pt-BR/products/cloud/features/infrastructure/parallel-replicas).