> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Início rápido do ClickHouse Cloud
> Guia de início rápido do ClickHouse Cloud
export const Image = ({img, alt, size}) => {
return
;
};
> A maneira mais rápida e fácil de começar a usar o ClickHouse é criar um novo
> serviço no [ClickHouse Cloud](https://console.clickhouse.cloud). Neste guia de início rápido, vamos deixar tudo pronto
> para você em três etapas simples.
## Crie um serviço ClickHouse
Para criar um serviço ClickHouse gratuito no [ClickHouse Cloud](https://console.clickhouse.cloud), basta se cadastrar seguindo estas etapas:
* Crie uma conta na [página de cadastro](https://console.clickhouse.cloud/signUp)
* Você pode optar por se cadastrar com seu e-mail ou via Google SSO, Microsoft SSO, AWS Marketplace, Google Cloud ou Microsoft Azure
* Se você se cadastrar com e-mail e senha, lembre-se de verificar seu endereço de e-mail nas próximas 24h pelo link que receberá por e-mail
* Faça login usando o nome de usuário e a senha que você acabou de criar
Depois de fazer login, o ClickHouse Cloud inicia o assistente de onboarding, que orienta você na criação de um novo serviço ClickHouse. Selecione a região desejada para implantar o serviço e dê um nome ao novo serviço:
Por padrão, novas organizações são colocadas no tier Scale e criarão 3 réplicas, cada uma com 4 VCPUs e 16 GiB de RAM. O [autoescalonamento vertical](/pt-BR/products/cloud/features/autoscaling/vertical) será ativado por padrão no tier Scale. Você pode alterar o tier da sua organização mais tarde na página 'Plans'.
Se necessário, personalize os recursos do serviço especificando um tamanho mínimo e máximo entre os quais as réplicas poderão escalar. Quando estiver tudo pronto, selecione `Create service`.
Parabéns! Seu serviço no ClickHouse Cloud já está em execução, e o onboarding foi concluído. Continue lendo para saber como começar a fazer a ingestão e consultar seus dados.
## Conectar ao ClickHouse
Há 2 maneiras de se conectar ao ClickHouse:
* Conectar usando nosso SQL Console na web
* Conectar com seu aplicativo
### Conectar usando o SQL Console
Para começar rapidamente, o ClickHouse oferece um SQL Console na web, para o qual você será redirecionado ao concluir o onboarding.
Crie uma aba de consulta e digite uma consulta simples para verificar se a conexão está funcionando:
```sql theme={null}
SHOW databases
```
Você deve ver 4 bancos de dados na lista, além de quaisquer outros que tenha adicionado.
É isso — você já pode começar a usar seu novo serviço ClickHouse!
### Conecte seu app
Clique no botão de conexão no menu de navegação. Uma janela modal será aberta, mostrando as credenciais do seu serviço e um conjunto de instruções sobre como se conectar usando sua interface ou clientes na sua linguagem.
Se você não encontrar o cliente para a sua linguagem, consulte nossa lista de [Integrations](/pt-BR/integrations/home).
## Adicionar dados
O ClickHouse é melhor com dados! Há diversas formas de adicionar dados e a maioria delas está disponível na página de Fontes de Dados, acessível pelo menu de navegação.
Você pode fazer upload de dados usando os seguintes métodos:
* Configure um ClickPipe para iniciar a ingestão de dados de fontes como S3, Postgres, Kafka e GCS
* Use o console SQL
* Use o cliente do ClickHouse
* Faça upload de um arquivo - os formatos aceitos incluem JSON, CSV e TSV
* Carregar dados de uma URL de arquivo
### ClickPipes
[ClickPipes](http://clickhouse.com/docs/integrations/clickpipes) é uma plataforma de integração gerenciada que torna a ingestão de dados de diversas fontes tão simples quanto clicar em alguns botões. Projetada para os workloads mais exigentes, a arquitetura robusta e escalável do ClickPipes garante desempenho e confiabilidade consistentes. O ClickPipes pode ser utilizado para necessidades de streaming de longo prazo ou para jobs pontuais de carregamento de dados.
### Adicionar dados usando o SQL Console
Como a maioria dos sistemas de gerenciamento de banco de dados, o ClickHouse agrupa tabelas logicamente em **databases**. Use o comando [`CREATE DATABASE`](/pt-BR/reference/statements/create/database) para criar um novo banco de dados no ClickHouse:
```sql theme={null}
CREATE DATABASE IF NOT EXISTS helloworld
```
Execute o seguinte comando para criar uma tabela chamada `my_first_table` no banco de dados `helloworld`:
```sql theme={null}
CREATE TABLE helloworld.my_first_table
(
user_id UInt32,
message String,
timestamp DateTime,
metric Float32
)
ENGINE = MergeTree()
PRIMARY KEY (user_id, timestamp)
```
No exemplo acima, `my_first_table` é uma tabela [`MergeTree`](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) com quatro colunas:
* `user_id`: um inteiro sem sinal de 32 bits ([UInt32](/pt-BR/reference/data-types/int-uint))
* `message`: um tipo de dado [String](/pt-BR/reference/data-types/string), que substitui tipos como `VARCHAR`, `BLOB`, `CLOB` e outros usados em outros sistemas de banco de dados
* `timestamp`: um valor [DateTime](/pt-BR/reference/data-types/datetime) que representa um instante no tempo
* `metric`: um número de ponto flutuante de 32 bits ([Float32](/pt-BR/reference/data-types/float))
**Motores de tabela**
Os motores de tabela determinam:
* Como e onde os dados são armazenados
* Quais consultas são aceitas
* Se os dados são replicados ou não
Há muitos motores de tabela para escolher, mas, para uma tabela simples em um servidor ClickHouse de nó único, a opção mais provável é [`MergeTree`](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree).
#### Uma Breve Introdução às Chaves Primárias
Antes de prosseguir, é importante entender como as chaves primárias funcionam no ClickHouse (a implementação
das chaves primárias pode parecer inesperada!):
* as chaves primárias no ClickHouse ***não são únicas*** para cada linha de uma tabela
A chave primária de uma tabela ClickHouse determina como os dados são ordenados quando gravados em disco. A cada 8.192 linhas ou 10 MB de
dados (denominado **granularidade do índice**) é criada uma entrada no arquivo de índice da chave primária. Esse conceito de granularidade
cria um **índice esparso** que cabe facilmente na memória, e os grânulos representam uma stripe da menor quantidade de
dados de coluna processada durante as consultas `SELECT`.
A chave primária pode ser definida usando o parâmetro `PRIMARY KEY`. Se você definir uma tabela sem especificar um `PRIMARY KEY`,
a chave passa a ser a tupla especificada na cláusula `ORDER BY`. Se você especificar tanto um `PRIMARY KEY` quanto um `ORDER BY`, a chave primária deve ser um subconjunto da ordem de ordenação.
A chave primária também é a chave de ordenação, que é uma tupla de `(user_id, timestamp)`. Portanto, os dados armazenados em cada
arquivo de coluna serão ordenados por `user_id` e depois por `timestamp`.
Para uma análise aprofundada dos conceitos fundamentais do ClickHouse, consulte ["Conceitos Fundamentais"](/pt-BR/concepts/core-concepts/index).
#### Insira dados na sua tabela
Você pode usar o conhecido comando [`INSERT INTO TABLE`](/pt-BR/reference/statements/insert-into) com o ClickHouse, mas é importante entender que cada inserção em uma tabela [`MergeTree`](/pt-BR/reference/engines/table-engines/mergetree-family/mergetree) resulta na criação de uma **part** no armazenamento.
**Prática recomendada do ClickHouse**
Insira um grande número de linhas por lote — dezenas de milhares ou até milhões de
linhas de uma só vez. Não se preocupe — o ClickHouse lida facilmente com esse volume — e isso [ajuda você a economizar](/pt-BR/concepts/best-practices/selecting-an-insert-strategy#batch-inserts-if-synchronous) ao enviar menos solicitações de gravação para o seu serviço.
Mesmo para um exemplo simples, vamos inserir mais de uma linha de uma vez:
```sql theme={null}
INSERT INTO helloworld.my_first_table (user_id, message, timestamp, metric) VALUES
(101, 'Hello, ClickHouse!', now(), -1.0 ),
(102, 'Insert a lot of rows per batch', yesterday(), 1.41421 ),
(102, 'Sort your data based on your commonly-used queries', today(), 2.718 ),
(101, 'Granules are the smallest chunks of data read', now() + 5, 3.14159 )
```
Observe que a coluna `timestamp` é preenchida com várias funções [**Date**](/pt-BR/reference/data-types/date) e [**DateTime**](/pt-BR/reference/data-types/datetime). O ClickHouse tem centenas de funções úteis que você pode [consultar na seção **Functions**](/pt-BR/reference/functions/index).
Vamos verificar se funcionou:
```sql theme={null}
SELECT * FROM helloworld.my_first_table
```
### Adicionar dados usando o ClickHouse Client
Você também pode se conectar ao seu serviço do ClickHouse Cloud usando uma ferramenta de linha de comando chamada [**clickhouse client**](/pt-BR/concepts/features/interfaces/cli). Clique em `Connect` no menu à esquerda para acessar esses detalhes. Na caixa de diálogo, selecione `Native` no menu suspenso:
1. Instale o [ClickHouse](/pt-BR/concepts/features/interfaces/cli).
2. Execute o comando, substituindo hostname, nome de usuário e senha pelos seus valores:
```bash theme={null}
./clickhouse client --host HOSTNAME.REGION.CSP.clickhouse.cloud \
--secure --port 9440 \
--user default \
--password
```
Se o prompt com o rosto sorridente aparecer, você está pronto para executar queries!
```response theme={null}
:)
```
3. Experimente executar a consulta a seguir:
```sql theme={null}
SELECT *
FROM helloworld.my_first_table
ORDER BY timestamp
```
Observe que a resposta é retornada em um formato de tabela bem organizado:
```response theme={null}
┌─user_id─┬─message────────────────────────────────────────────┬───────────timestamp─┬──metric─┐
│ 102 │ Insert a lot of rows per batch │ 2022-03-21 00:00:00 │ 1.41421 │
│ 102 │ Sort your data based on your commonly-used queries │ 2022-03-22 00:00:00 │ 2.718 │
│ 101 │ Hello, ClickHouse! │ 2022-03-22 14:04:09 │ -1 │
│ 101 │ Granules are the smallest chunks of data read │ 2022-03-22 14:04:14 │ 3.14159 │
└─────────┴────────────────────────────────────────────────────┴─────────────────────┴─────────┘
4 rows in set. Elapsed: 0.008 sec.
```
4. Adicione uma cláusula [`FORMAT`](/pt-BR/reference/statements/select/format) para especificar um dos [muitos formatos de saída suportados pelo ClickHouse](/pt-BR/reference/formats/index):
```sql theme={null}
SELECT *
FROM helloworld.my_first_table
ORDER BY timestamp
FORMAT TabSeparated
```
Na consulta acima, a saída é retornada separada por tabulações:
```response theme={null}
Query id: 3604df1c-acfd-4117-9c56-f86c69721121
102 Insert a lot of rows per batch 2022-03-21 00:00:00 1.41421
102 Sort your data based on your commonly-used queries 2022-03-22 00:00:00 2.718
101 Hello, ClickHouse! 2022-03-22 14:04:09 -1
101 Granules are the smallest chunks of data read 2022-03-22 14:04:14 3.14159
4 rows in set. Elapsed: 0.005 sec.
```
5. Para sair do `clickhouse client`, digite o comando **exit**:
```bash theme={null}
exit
```
### Fazer upload de um arquivo
Uma tarefa comum ao começar a trabalhar com um banco de dados é inserir dados que você já possui em arquivos. Disponibilizamos alguns
dados de exemplo online que você pode inserir, representando dados de clickstream — incluindo um ID de usuário, uma URL visitada e
o timestamp do evento.
Suponha que temos o seguinte texto em um arquivo CSV chamado `data.csv`:
```bash title="data.csv" theme={null}
102,This is data in a file,2022-02-22 10:43:28,123.45
101,It is comma-separated,2022-02-23 00:00:00,456.78
103,Use FORMAT to specify the format,2022-02-21 10:43:30,678.90
```
1. O comando a seguir insere os dados na tabela `my_first_table`:
```bash theme={null}
./clickhouse client --host HOSTNAME.REGION.CSP.clickhouse.cloud \
--secure --port 9440 \
--user default \
--password \
--query='INSERT INTO helloworld.my_first_table FORMAT CSV' < data.csv
```
2. Observe que as novas linhas agora aparecem na tabela ao consultar pelo SQL Console:
**Filtragem por lista de acesso de IPs**
Antes de prosseguir, recomendamos configurar a filtragem por lista de acesso de IPs.
Consulte ["Configurar filtros de IP"](/pt-BR/products/cloud/guides/security/connectivity/setting-ip-filters) para mais detalhes.
## O que vem a seguir?
* O [Tutorial](/pt-BR/get-started/quickstarts/tutorial) mostra como inserir 2 milhões de linhas em uma tabela e escrever algumas consultas analíticas
* Temos uma lista de [datasets de exemplo](/pt-BR/get-started/sample-datasets/index) com instruções sobre como inseri-los
* Confira nosso vídeo de 12 minutos sobre [Primeiros passos com ClickHouse](https://clickhouse.com/company/events/getting-started-with-clickhouse/)
* Se seus dados vêm de uma fonte externa, consulte nossa [coleção de guias de integração](/pt-BR/integrations/home) para se conectar a filas de mensagens, bancos de dados, pipelines e muito mais
* Se você estiver usando uma ferramenta de visualização/BI, consulte os [guias do usuário para conectar uma UI ao ClickHouse](/pt-BR/integrations/connectors/data-visualization/index)
* O guia do usuário sobre [chaves primárias](/pt-BR/guides/clickhouse/data-modelling/sparse-primary-indexes) traz tudo o que você precisa saber sobre chaves primárias e como defini-las