> ## Knowledge Base Index
> Fetch the complete knowledge base index at: https://help.squarecloud.app/sitemap.xml
> Use this file to discover available pages before exploring further.
> Pure-Markdown content can be obtained by appending a '.md' suffix to the content URLs listed in the sitemap (without the trailing slash).

# Como criar um bot de música(Lavalink)

# Como Hospedar um Bot de Música com Lavalink na Square Cloud

Se você já tentou criar ou hospedar um bot de música para o Discord recentemente, sabe que processar áudio diretamente na mesma aplicação do bot pode consumir muita CPU e gerar engasgos na reprodução. A solução profissional para isso é o **Lavalink**, um servidor de áudio standalone baseado em Java, otimizado especificamente para o Discord.

Neste tutorial, você aprenderá o passo a passo para hospedar tanto o servidor Lavalink quanto o seu bot de música na **Square Cloud**, garantindo estabilidade e áudio de alta qualidade 24/7.

---

## 🛠️ Arquitetura da Solução

Para que o sistema funcione, dividiremos o projeto em duas aplicações independentes dentro da Square Cloud:

1. **O Servidor Lavalink:** Responsável por se conectar ao YouTube/Spotify/SoundCloud, baixar o áudio, decodificar e transmitir.
2. **O Bot Discord:** Responsável por receber os comandos dos usuários (`!play`, `!skip`) e gerenciar a fila, enviando as instruções de reprodução para o Lavalink.
---

## Passo 1: Configurando e Hospedando o Lavalink

O Lavalink precisa de um arquivo de configuração chamado `application.yml` e do arquivo executável `.jar`.

### 1. Estrutura de arquivos do Lavalink
Crie uma pasta no seu computador chamada `lavalink-server` com os seguintes arquivos:

* `lavalink.jar` (Baixe a versão mais recente do repositório oficial do Lavalink no GitHub)
* `application.yml`

### 2. Configurando o `application.yml`
Este é o arquivo que define a porta e a senha que o seu bot usará para se conectar. Use a configuração base abaixo:

```yaml
server:
  port: 80
  address: 0.0.0.0
lavalink:
  server:
    password: "SUA_SENHA_SUPER_SEGURA"
    sources:
      youtube: true
      bandcamp: true
      soundcloud: true
      twitch: true
      vimeo: true
      mixer: false
      http: true
      local: false
    filters:
      volume: true
      equalizer: true
    bufferDurationMs: 400
    youtubePlaylistLoadLimit: 6 // Limite de páginas de playlist
    playerUpdateInterval: 5
    youtubeSearchEnabled: true
    soundcloudSearchEnabled: true
    gc-warnings: true
```
> ⚠️ **Nota sobre Memória:** O Lavalink roda sobre a JVM (Java Virtual Machine), que costuma ser exigente. Recomendamos alocar no mínimo **512MB** de RAM para evitar travamentos durante o carregamento de músicas pesadas.

### 3. Envio para a Square Cloud
1. Compacte os três arquivos (`lavalink.jar`, `application.yml`) em um arquivo **.zip**.
2. Vá para o Dashboard da Square Cloud, clique em **Nova aplicação**, anexe o zip e selecione arquivo principal o jar e marque publicar na web.
3. Assim que enviar, vá na aba **Configurações** do seu Lavalink na Square Cloud e copie na aba de **Network** o **Domínio Público** (ex: `seu-lavalink.squareweb.app`).

---

## Passo 2: Configurando o Bot de Música

Agora que o servidor de áudio está online, você pode escolher a linguagem de programação de sua preferência para construir o bot. Abaixo estão os exemplos em **Node.js** e **Python**.

### Opção A: Implementação em Python (usando `wavelink`)

Para projetos em Python, a biblioteca `wavelink` é a integração mais robusta e moderna com o Lavalink.

#### 1. Arquivos necessários:
* `main.py`
* `requirements.txt`

#### 2. Dependências (`requirements.txt`):
```text
discord.py
wavelink
```

#### 3. Código do Bot (`main.py`):
```python
import discord
from discord.ext import commands
import wavelink

class MusicBot(commands.Bot):
    def __init__(self):
        intents = discord.Intents.default()
        intents.message_content = True
        super().__init__(command_prefix="!", intents=intents)

    async def setup_hook(self):
        # Configura o nó do Lavalink apontando para a Square Cloud
        node = wavelink.Node(
            uri="[https://seu-lavalink.squareweb.app:443](https://seu-lavalink.squareweb.app:443)", # Domínio gerado com a porta 443 (SSL)
            password="SUA_SENHA_SUPER_SEGURA"
        )
        await wavelink.Pool.connect(nodes=[node], client=self)

bot = MusicBot()

@bot.event
async def on_ready():
    print(f"Bot logado como {bot.user}")

@bot.event
async def on_wavelink_node_ready(payload: wavelink.NodeReadyEventPayload):
    print(f"Nó Lavalink \"{payload.node.identifier}\" está conectado e pronto!")

@bot.command()
async def play(ctx: commands.Context, *, search: str):
    if not ctx.author.voice:
        return await ctx.send("Você precisa estar em um canal de voz!")

    # Conecta ao canal de voz se não estiver conectado
    if not ctx.voice_client:
        vc: wavelink.Player = await ctx.author.voice.channel.connect(cls=wavelink.Player)
    else:
        vc: wavelink.Player = ctx.voice_client

    # Busca a música
    tracks = await wavelink.Tracks.search(search)
    if not tracks:
        return await ctx.send("Nenhuma música encontrada.")

    track = tracks[0]
    await vc.play(track)
    await ctx.send(f"Tocando agora: **{track.title}**")

bot.run("SEU_DISCORD_BOT_TOKEN")
```

---

### Opção B: Implementação em Node.js (usando `erela.js`)

Se preferir JavaScript/TypeScript, você pode usar a estrutura abaixo.

#### 1. Arquivos necessários:
* `index.js`
* `package.json`

#### 2. Dependências (`package.json`):
```json
{
  "dependencies": {
    "discord.js": "^14.x",
    "erela.js": "^2.x"
  }
}
```

#### 3. Código do Bot (`index.js`):
```javascript
const { Client, GatewayIntentBits } = require("discord.js");
const { Manager } = require("erela.js");

const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent,
        GatewayIntentBits.GuildVoiceStates
    ]
});

client.manager = new Manager({
    nodes: [
        {
            host: "seu-lavalink.squareweb.app", // Domínio fornecido pela Square Cloud
            port: 443, // Porta padrão segura para HTTPS/WSS
            password: "SUA_SENHA_SUPER_SEGURA",
            secure: true // Força o uso de SSL/TLS da Square Cloud
        }
    ],
    send(id, payload) {
        const guild = client.guilds.cache.get(id);
        if (guild) guild.shard.send(payload);
    }
});

client.on("raw", (d) => client.manager.updateVoiceState(d));

client.once("ready", () => {
    console.log(`Bot logado como ${client.user.tag}`);
    client.manager.init(client.user.id);
});

client.manager.on("nodeConnect", node => console.log(`Nó Lavalink "${node.options.identifier}" conectado.`));
client.manager.on("nodeError", (node, error) => console.log(`Erro no Nó: ${error.message}`));

client.login("SEU_DISCORD_BOT_TOKEN");
```

---

## Passo 3: Colocando Tudo Juntos

1. No dashboard da Square Cloud, inicialize o seu **Lavalink Server** e certifique-se de que ele exibe o status `Online`.
2. Escolha uma das opções acima (Python ou Node.js), coloque todos os arquivos da pasta do bot escolhido dentro de um arquivo **.zip**.
3. Envie o zip do bot para a Square Cloud através do botão **Nova aplicação**.
4. Inicialize o bot e abra o terminal de logs. Se a conexão tiver sucesso, você verá a mensagem confirmando que o Nó Lavalink está pronto.

---

## 💡 Dicas de Otimização e Troubleshooting

* **Erro de Conexão (WebSocket Error / Connection Refused):** A Square Cloud gerencia os domínios web sob conexões seguras com certificados SSL próprios. Por isso, ao configurar o seu bot (seja em Python ou Node.js), use obrigatoriamente a porta pública `443` e habilite o parâmetro `secure / https / wss`, em vez de tentar acessar diretamente a porta interna `80`.
* **Quedas e Latência no Áudio:** O processamento de áudio depende muito da CPU disponível. Monitore os recursos do Lavalink no Dashboard. Se perceber picos recorrentes de 100% de uso de CPU ao decodificar streams, considere aumentar os recursos alocados do servidor Lavalink e do bot para garantir mais núcleos de processamento.
* **Estabilidade do Bot:** Bots de música tendem a acumular objetos de filas muito extensas na memória RAM. Monitore frequentemente o consumo do bot para mitigar *Memory Leaks* utilizando limpezas periódicas de filas inativas.

---

## ⚠️ O Grande Desafio: Restrições de IP do YouTube (Sign-in Required)

Se você configurar tudo corretamente e, ao tentar tocar uma música, o bot simplesmente pular a faixa ou exibir um erro como `403 Forbidden` ou `Sign-in required`, você acabou de esbarrar na proteção do YouTube.

O YouTube bloqueia agressivamente requisições vindas de **IPs de datacenters** (como os servidores da Square Cloud, AWS, Google Cloud, etc.) para evitar abusos e web scraping de áudio. Como milhares de bots compartilham as mesmas faixas de IP de grandes servidores, esses IPs entram rapidamente na "lista negra" da plataforma.

### Como contornar esse problema?

Para fazer o seu Lavalink na Square Cloud funcionar com links do YouTube de forma estável, você tem três caminhos principais:

1. **Utilizar o Plugin Youtube-Source com Cookies:** As versões mais recentes das fontes do Lavalink permitem que você exporte um arquivo de cookies de uma conta do YouTube secundária (usando extensões de navegador como *Get cookies.txt LOCALLY*) e o configure no servidor. Isso simula um usuário real autenticado.
2. **Mudar para Fontes Alternativas:** Configurar o bot para utilizar nativamente o **SoundCloud**, **Bandcamp** ou **Twitch** como mecanismos de busca padrão no `application.yml` contorna completamente o bloqueio do YouTube. Para o **Spotify**, lembre-se de que os plugins apenas convertem os metadados da música (nome e artista) para buscá-la em uma plataforma de áudio; portanto, o áudio final ainda precisará vir de uma fonte que não esteja bloqueada (como o SoundCloud).

## Compatibilidade de versões (Lavalink v3 x v4) e conexão

Use sempre uma **versão do Lavalink compatível com o client (wrapper)** do seu bot: o **Lavalink v4 é baseado em REST e não conversa com um client v3**, o que derruba o WebSocket. Resumo da rede na Square Cloud: o **servidor Lavalink abre na porta 80** e o **client conecta na porta 443 com `secure: true`**. Se aparecer `WebSocket closed abnormally (1006)`, veja [Lavalink closed abnormally (1006): como resolver](https://help.squarecloud.app/pt-br/article/lavalink-closed-abnormally-1006-como-resolver-rskx6s/).