Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Exportando para servidores dedicados

Se você deseja executar um servidor dedicado para seu projeto em uma máquina sem GPU ou servidor gráfico disponível, será necessário executar o Godot com o servidor de exibição headless e o driver de áudio Dummy.

Desde o Godot 4.0, isso pode ser feito executando um binário do Godot em qualquer plataforma com o argumento de linha de comando --headless, ou executando um projeto exportado como servidor dedicado. Você não precisa mais usar um binário de servidor especializado, ao contrário do Godot 3.x.

Editor versus template de exportação

É possível usar o binário do editor ou do template de exportação (debug ou release) no modo headless. Qual você deve usar depende do seu caso de uso:

Template de exportação: Use este para executar servidores dedicados. Ele não contém funcionalidades do editor e, portanto, é menor e mais otimizado.
Editor: Este binário contém funcionalidades do editor e foi projetado para ser usado na exportação de projetos. Este binário pode ser usado para executar servidores dedicados, mas não é recomendado, pois é maior e menos otimizado.

Abordagens de exportação

Há duas maneiras de exportar um projeto para um servidor:

Crie uma predefinição de exportação separada para a plataforma que hospedará o servidor e então exporte seu projeto normalmente.
Exporte apenas um arquivo PCK, de preferência para a plataforma que corresponde à plataforma que hospedará o servidor. Coloque este arquivo PCK na mesma pasta que um binário de template de exportação, renomeie o binário para ter o mesmo nome do PCK (menos a extensão do arquivo) e execute o binário.

Ambos os métodos devem produzir o mesmo resultado. O restante da página focará na primeira abordagem.

Veja Exportando projetos para mais informações.

Exportando um projeto para um servidor dedicado

Se você exportar um projeto como de costume ao direcionar para um servidor, notará que o arquivo PCK é tão grande quanto o do cliente. Isso ocorre porque ele inclui todos os recursos, inclusive aqueles que o servidor não precisa (como dados de textura). Além disso, o modo headless não será usado automaticamente; o usuário terá que especificar --headless para garantir que nenhuma janela seja aberta.

Muitos recursos, como texturas, podem ser removidos do arquivo PCK para reduzir bastante o seu tamanho. O Godot oferece uma maneira de fazer isso para texturas e materiais de forma a preservar as referências em arquivos de cena ou de recursos (internos ou externos).

Para começar a fazer isso, certifique-se de ter um preset de exportação dedicado para o seu servidor, selecione-o, vá para a aba Resources e altere o modo de exportação:

Escolhendo o modo de exportação **Export as dedicated server** no preset de exportação

Quando este modo de exportação é escolhido, a tag de recurso dedicated_server é adicionada automaticamente ao projeto exportado.

Nota

Se você não deseja usar este modo de exportação, mas ainda quer a tag de recurso, pode escrever o nome dedicated_server na aba Features do preset de exportação. Isso também forçará o uso de --headless ao executar o projeto exportado.

Após selecionar este modo de exportação, você verá uma lista de recursos no projeto:

Escolhendo recursos para manter, manter com visuais removidos ou remover

Marcar uma caixa permite que você sobrescreva as opções para o arquivo ou pasta especificado. Marcar as caixas não afeta quais arquivos são exportados; isso é definido pelas opções selecionadas para cada caixa de seleção.

Os arquivos dentro de uma pasta marcada usarão automaticamente a opção da pasta pai por padrão, o que é indicado pelo sufixo (Inherited) no nome da opção (e o nome da opção ficando acinzentado). Para alterar a opção de um arquivo cuja opção está atualmente herdada, você deve marcar a caixa ao lado dele primeiro.

Strip Visuals: Exporta este recurso com os arquivos visuais (texturas e materiais) substituídos por classes de placeholder. As classes de placeholder armazenam o tamanho da imagem (já que às vezes é usado para posicionar elementos em uma cena 2D), mas nada mais.
Keep: Exporta este recurso como de costume, com os arquivos visuais intactos.
Remove: O arquivo não é incluído no PCK. Isso é útil para ignorar cenas e recursos que apenas o cliente precisa. Se fizer isso, certifique-se de que o servidor não referencie essas cenas e recursos exclusivos do cliente de nenhuma forma.

A recomendação geral é usar o Strip Visuals sempre que possível, a menos que o servidor precise acessar dados de imagem, como as cores dos pixels. Por exemplo, se o seu servidor gera dados de colisão com base no conteúdo de uma imagem, você precisa usar Keep para essa imagem específica.

Dica

Para verificar a estrutura de arquivos do seu PCK exportado, use o botão Export PCK/ZIP... com a extensão de arquivo .zip e abra o arquivo ZIP resultante em um gerenciador de arquivos.

Aviso

Tenha cuidado ao usar o modo Remove, pois cenas/recursos que referenciam um arquivo removido não poderão mais ser carregados com sucesso.

Se você deseja remover recursos específicos, mas quer que as cenas ainda possam ser carregadas sem eles, terá que remover a referência no arquivo de cena e carregar os arquivos nas propriedades dos nós usando load() em um script. Essa abordagem pode ser usada para remover recursos que o Godot ainda não suporta substituir por placeholders, como áudio.

Remover texturas costuma ser o que causa o maior impacto no tamanho do PCK, por isso é recomendado focar no Strip Visuals no início.

Com as opções acima utilizadas, um PCK para o cliente (que exporta todos os recursos normalmente) ficará assim:

.
├── .godot
│   ├── exported
│   │   └── 133200997
│   │       └── export-78c237d4bfdb4e1d02e0b5f38ddfd8bd-scene.scn
│   ├── global_script_class_cache.cfg
│   ├── imported
│   │   ├── map_data.png-ce840618f399a990343bfc7298195a13.ctex
│   │   ├── music.ogg-fa883da45ae49695a3d022f64e60aee2.oggvorbisstr
│   │   └── sprite.png-7958af25f91bb9dbae43f35388f8e840.ctex
│   └── uid_cache.bin
├── client
│   ├── music.ogg.import
│   └── sprite.png.import
├── server
│   └── map_data.png.import
├── test
│   └── scene.gd
└── unused
│   └── development_test.gd
├── project.binary
├── scene.gd
├── scene.tscn.remap

A estrutura de arquivos do PCK para o servidor ficará assim:

.
├── .godot
│   ├── exported
│   │   └── 3400186661
│   │       ├── export-78c237d4bfdb4e1d02e0b5f38ddfd8bd-scene.scn
│   │       ├── export-7958af25f91bb9dbae43f35388f8e840-sprite.res  # Placeholder texture
│   │       └── export-fa883da45ae49695a3d022f64e60aee2-music.res
│   ├── global_script_class_cache.cfg
│   ├── imported
│   │   └── map_data.png-ce840618f399a990343bfc7298195a13.ctex
│   └── uid_cache.bin
├── client
│   ├── music.ogg.import
│   └── sprite.png.import  # Points to placeholder texture
└── server
│   └── map_data.png.import
├── project.binary
├── scene.gd
├── scene.tscn.remap

Iniciando o servidor dedicado

Se o cliente e o servidor fizerem parte do mesmo projeto da Godot, você terá que adicionar uma maneira de iniciar o servidor diretamente usando um argumento de linha de comando.

Se você exportou o projeto usando o modo de exportação Export as dedicated server (ou adicionou dedicated_server como uma tag de recurso customizada), você pode usar a tag de recurso dedicated_server para detectar se um PCK de servidor dedicado está sendo usado:

# Note: Feature tags are case-sensitive.
if OS.has_feature("dedicated_server"):
    # Run your server startup code here...
    pass

// Note: Feature tags are case-sensitive.
if (OS.HasFeature("dedicated_server"))
{
    // Run your server startup code here...
}

Se você também deseja hospedar um servidor ao utilizar o argumento de linha de comando integrado --headless, isso pode ser feito adicionando o seguinte trecho de código ao método _ready() da sua cena principal (ou de um autoload):

if DisplayServer.get_name() == "headless":
    # Run your server startup code here...
    #
    # Using this check, you can start a dedicated server by running
    # a Godot binary (editor or export template) with the `--headless`
    # command-line argument.
    pass

using System.Linq;

if (DisplayServer.GetName() == "headless")
{
    // Run your server startup code here...
    //
    // Using this check, you can start a dedicated server by running
    // a Godot binary (editor or export template) with the `--headless`
    // command-line argument.
}

Se você quiser usar um argumento de linha de comando personalizado, isso pode ser feito adicionando o seguinte trecho de código ao método _ready() da sua cena principal (ou de um autoload):

if "--server" in OS.get_cmdline_user_args():
    # Run your server startup code here...
    #
    # Using this check, you can start a dedicated server by running
    # a Godot binary (editor or export template) with the `--server`
    # command-line argument.
    pass

using System.Linq;

if (OS.GetCmdlineUserArgs().Contains("--server"))
{
    // Run your server startup code here...
    //
    // Using this check, you can start a dedicated server by running
    // a Godot binary (editor or export template) with the `--server`
    // command-line argument.
}

É uma boa ideia adicionar pelo menos um dos argumentos de linha de comando acima para iniciar um servidor, pois ele pode ser usado para testar a funcionalidade do servidor a partir da linha de comando sem ter que exportar o projeto.

Se seu cliente e servidor são projetos do Godot separados, seu servidor provavelmente deve ser configurado de uma maneira onde a execução da cena principal iniciará um servidor automaticamente.

Próximos passos

No Linux, para fazer seu servidor dedicado reiniciar após uma falha ou reinicialização do sistema, você pode criar um serviço systemd. Isso também permite visualizar os logs do servidor de forma mais conveniente, com rotação automática de logs fornecida pelo systemd. Ao tornar seu projeto hospedável como um serviço systemd, você também deve habilitar a configuração de projeto application/run/flush_stdout_on_print. Dessa forma, o journald (o serviço de logs do systemd) pode coletar logs enquanto o processo está em execução.

Se você já tem experiência com contêineres, você pode considerar colocar seu servidor dedicado em um contêiner Docker. Desta maneira, ele pode ser usado mais facilmente em uma configuração escalar automática (que está fora do escopo desse tutorial).