# Interface `Client` da Azion

import DocButton from '~/components/webkit/DocButton.vue';

A interface **Client** da Azion fornece um meio unificado para interagir com todos os produtos e serviços. Você pode usar o `client` para acessar e gerenciar todos os produtos e funcionalidades no Object Storage, SQL Database, Purge, KV, Domains, e mais. 

Ao instanciar um cliente, você pode definir explicitamente configurações como `token` e `debug` como parâmetros. Você pode então interagir com as funcionalidades da Azion diretamente através do `client`, de maneira simplificada e centralizada.

<DocButton href="/pt-br/documentacao/produtos/azion-lib/visao-geral/" label="Saiba mais sobre as Azion Libraries" kind="secondary" size="medium" />

---

## Use o Client da Azion

Para usar a interface **Client**, importe a função `createClient` das **Azion Libraries**. Você pode então passar seu `token` como parâmetro e usar a instância do `client` para acessar módulos e suas funcionalidades.

O exemplo abaixo mostra uma implementação em **JavaScript**:

```js
import { createClient } from 'azion';

// Instancie o cliente
const client = createClient({ token: 'seu-token-api', debug: true });

// Acesse o módulo SQL e crie um Banco de Dados
const { data: newDatabase, error } = await client.sql.createDatabase('meu-novo-banco-de-dados');
if (data) {
  console.log(`Banco de dados criado com ID: ${newDatabase.id}`);
} else {
  console.error('Falha ao criar banco de dados', error);
}
```

Se você está usando TypeScript, importe os tipos apropriados como no exemplo abaixo:

```ts
import { createClient } from 'azion';
import type { AzionClient } from 'azion/client';
import type { AzionDatabaseResponse } from 'azion/sql';
// Instancie o cliente
const client = createClient({ token: 'seu-token-api', debug: true });

// Acesse o módulo SQL e crie um Banco de Dados
const { data: newDatabase, error }: AzionDatabaseResponse<AzionDatabase> = await client.sql.createDatabase('meu-novo-banco-de-dados');
if (data) {
  console.log(`Banco de dados criado com ID: ${newDatabase.id}`);
} else {
  console.error('Falha ao criar banco de dados', error);
}
```

---

## Client da Azion vs funções independentes de pacote

Cada módulo tem seu próprio cliente interno que gerencia as interações. O exemplo abaixo mostra o uso de um cliente para um módulo específico:

```js
import { createClient, StorageClient } from 'azion/storage';

// Crie um cliente para o módulo Storage
const client: StorageClient = createClient({ token: 'seu-token-api', debug: true });

const { data, error }: AzionStorageResponse<AzionBucket> = await client.createBucket({
  name: 'meu-novo-bucket',
  edge_access: 'public',
});

if (data) {
  console.log(`Bucket criado com nome: ${data.name}`);
} else {
  console.error('Falha ao criar bucket', error);
}
```

Também é possível usar funções específicas diretamente de seus pacotes, sem usar um `client`, como mostrado no exemplo abaixo.

:::note
Quando usar funções individuais sem um `client`, você precisa configurar tokens e configurações via variáveis de ambiente (por exemplo, usando um arquivo `.env`).
:::

```js
import { createDatabase } from 'azion/sql';

// Chame a função createDatabase diretamente de seu pacote
const { data, error } = await createDatabase('meu-novo-banco-de-dados', { debug: true });
if (data) {
  console.log(`Banco de dados criado com ID: ${data.id}`);
} else {
  console.error('Falha ao criar banco de dados', error);
}
```

Essa flexibilidade permite que você gerencie tudo através do `client` para simplificar ou chame funções específicas de cada pacote com mais controle sobre as configurações do ambiente.

---

## Módulos disponíveis

O Client da Azion fornece acesso aos seguintes módulos:

| Módulo | Descrição |
|--------|-----------|
| `storage` | Gerenciar buckets e objetos no Object Storage. |
| `sql` | Criar e consultar bancos de dados SQL. |
| `purge` | Limpar cache por URL, cache key ou wildcard. |
| `domains` | Gerenciar domínios e suas configurações. |
| `kv` | Interagir com o KV Store usando uma API similar ao Redis. |

### Usando o módulo KV

O módulo `kv` fornece uma interface similar ao Redis para operações de chave-valor:

```typescript
import { createClient } from 'azion';

const client = createClient({ token: 'seu-token-api', debug: true });

// Acessar o módulo KV
const kvClient = await client.kv
  .on('error', (err) => console.error('Erro KV:', err))
  .connect();

// Armazenar um valor
await kvClient.set('user:123', JSON.stringify({ name: 'John' }), {
  expiration: { type: 'EX', value: 3600 }, // TTL de 1 hora
});

// Recuperar um valor
const userData = await kvClient.get('user:123');
console.log('Dados do usuário:', userData);

// Operações de hash
await kvClient.hSet('config', 'theme', 'dark');
const config = await kvClient.hGetAll('config');

// Desconectar quando terminar
await kvClient.disconnect();
```

Para mais detalhes sobre operações KV, veja a [documentação da biblioteca KV](/pt-br/documentacao/produtos/azion-lib/kv/).