> For the complete documentation index, see [llms.txt](https://docs.edgegap.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.edgegap.com/ru/docs/sample-projects/godot/godotsteam-server.md).

# Сервер GodotSteam на Edgegap

Выделенный сервер GodotSteam на Edgegap: экспорт для Linux без графического интерфейса, вход в Steam и билеты аутентификации, Docker, развертывание и клиенты Steam.

[GodotSteam Server](https://codeberg.org/godotsteam/godotsteam-server) — специализированная версия GodotSteam для выделенных серверов. Она оборачивает API игровых серверов Steam (`SteamGameServer`) для Godot, благодаря чему сервер без графического интерфейса может войти в Steam, получить собственный Steam ID и проверять, что каждый подключившийся игрок — настоящий пользователь Steam, которому принадлежит ваша игра.

В этом руководстве мы создадим проект Godot 4 с нуля и запустим выделенный сервер GodotSteam Server на Edgegap. К нему подключится клиент Steam и успешно пройдёт проверку билета аутентификации Steam. Игроки подключаются через встроенный в Godot протокол ENet (UDP), а Steam используется для проверки личности, владения игрой и борьбы с читерством.

Полный проект из этого руководства доступен на GitHub: [edgegap/server-sample-godotsteam-dedicated-server](https://github.com/edgegap/server-sample-godotsteam-dedicated-server). Клонируйте репозиторий, выполните команду `./tools/fetch-godotsteam.sh` для загрузки дополнений GodotSteam, а затем следуйте инструкциям в README, чтобы запустить сервер всего несколькими командами.

{% hint style="success" %}
**Проверено 2026-11-09** с Godot 4.7.2, GodotSteam Server 4.12.1 (GDExtension), GodotSteam 4.24 (GDExtension) и Steamworks SDK 1.65: сервер анонимно вошёл в Steam на Edgegap, клиент Windows подключился через ENet, Steam проверил его билет аутентификации, а развёртывание автоматически остановилось после отключения клиента.
{% endhint %}

## ✔️ Подготовка

Перед началом [создайте бесплатную учётную запись Edgegap](https://app.edgegap.com/auth/register) (банковская карта не требуется).

**Установите на компьютере для разработки необходимые компоненты:**

* [Godot 4.4 или новее](https://godotengine.org/download) с **шаблонами экспорта для Linux** (Редактор / Управление шаблонами экспорта). Для GDExtension GodotSteam Server требуется Godot 4.4 или новее.
* [Docker Desktop (или Docker CLI)](https://www.docker.com/products/docker-desktop/).
* Клиент Steam: установите его и войдите в аккаунт, чтобы протестировать клиент игры.
* Идентификатор приложения Steam (App ID). В этом руководстве используется `480` (Spacewar) — тестовое приложение Valve, доступное каждому пользователю Steam. Перед выпуском игры замените его идентификатором собственного приложения.

{% hint style="info" %}
Впервые работаете с выделенными серверами в Godot? Сначала ознакомьтесь с руководством [Godot — начало работы](https://docs.edgegap.com/ru/godot.md) и изучите этапы экспорта, настройки Docker и развёртывания с помощью плагина Edgegap, а затем вернитесь, чтобы добавить Steam.
{% endhint %}

## 🧩 1. Установка GodotSteam

GodotSteam представлен в двух вариантах. Для игры с клиентом и сервером нужны оба:

| Дополнение            | Синглтон      | Используется в    | Загрузка                                                                                                                                                                                                          |
| --------------------- | ------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **GodotSteam Server** | `SteamServer` | Выделенный сервер | [Релизы на Codeberg](https://codeberg.org/godotsteam/godotsteam-server/releases) (`godotsteam-server-<version>-gdextension-plugin-4.4.zip`) или «GodotSteam Server GDExtension 4.4+» в библиотеке ресурсов Godot  |
| **GodotSteam**        | `Steam`       | Игровой клиент    | [Релизы на Codeberg](https://codeberg.org/godotsteam/godotsteam/releases) (`godotsteam-<version>-gdextension-plugin-4.4.zip`) или «GodotSteam GDExtension 4.4+» в библиотеке ресурсов или магазине ресурсов Godot |

☑️ Распакуйте оба архива в проект. В нём должны появиться каталоги `addons/godotsteam_server/` и `addons/godotsteam/`. Библиотека Steamworks API (`libsteam_api.so`, `steam_api64.dll`, ...) уже входит в каждый аддон.

{% hint style="info" %}
**GDExtension или модуль?** В этом руководстве используются сборки GDExtension: они работают со стандартным редактором Godot и стандартными шаблонами экспорта. Сборки с модулем (`godotsteam-server` шаблоны и редактор) — это специальные сборки Godot. Если вы используете их, экспортируйте сервер с шаблонами GodotSteam Server и пропустите папку аддона. Ни в коем случае не смешивайте сборки GDExtension и модуля в одном проекте.
{% endhint %}

{% hint style="warning" %}
Если добавить оба аддона в один проект, редактор выводит ошибки, например: `Attempt to register extension class 'SteamProjectSettings', which appears to be already registered`. Оба аддона объявляют этот класс настроек. В наших тестах это не повлияло ни на сервер, ни на клиент, а при каждом экспорте, описанном в этом руководстве, используется только один из двух аддонов, поэтому в экспортированных сборках этой ошибки нет.
{% endhint %}

✅ Теперь можно перейти к следующему шагу.

## 🔧 2. Добавьте скрипт сервера и клиента

Приведённый ниже скрипт — это автозагрузка, которая работает как выделенный сервер в серверном экспорте и как клиент во всех остальных случаях. В нём используется `Engine.get_singleton()` , поэтому скрипт разбирается даже в экспортированных сборках, содержащих только один из двух аддонов.

**Что делает сервер:**

1. `serverInitEx()` запускает API игрового сервера Steam, указывая порт игры, порт запросов, режим аутентификации и строку версии.
2. Задаёт продукт, описание, каталог мода, имя и количество игроков на сервере. Steam принимает эти значения только **до** входа в систему.
3. `logOnAnonymous()` выполняет вход в Steam с временным Steam ID, либо `logOn(token)` — с токеном входа на игровой сервер, если задан `STEAM_GSLT` (см. [#steam-account-and-game-server-login-token](#steam-account-and-game-server-login-token "mention")).
4. Открывает сервер ENet на порту `7777`. При подключении узла сервер отправляет ему свой Steam ID и ждёт до 15 секунд билет аутентификации Steam.
5. `beginAuthSession()` передаёт билет Steam; сигнал `validate_auth_ticket_response` сообщает, разрешено ли игроку подключиться. Игроки, не прошедшие проверку или не отправившие билет, отключаются.
6. Когда все игроки покинут сервер (или никто не подключится в течение 2 минут), сервер выходит из Steam и удаляет собственное развёртывание Edgegap, чтобы вам не приходилось платить за пустой сервер.

**Что делает клиент:** инициализирует Steam с вашим App ID, подключается через ENet, запрашивает у Steam билет сеанса аутентификации, привязанный к Steam ID сервера, ждёт подтверждения билета от Steam и отправляет его серверу.

{% hint style="warning" %}
Сигналы Steam срабатывают только при вызове `run_callbacks()`. Скрипт вызывает `SteamServer.run_callbacks()` (а также `Steam.run_callbacks()` на клиенте) каждый кадр в `_process`. Настройка проекта GodotSteam «embed callbacks» привязывает обработчики к кадрам рендеринга, которые безголовый сервер не отрисовывает.
{% endhint %}

☑️ Сохраните скрипт как `res://net/session.gd`.

{% code title="net/session.gd" lineNumbers="true" expandable="true" %}

```gdscript
extends Node
## Один autoload для обеих сторон соединения.
## Сервер (экспорт `dedicated_server` или `-- --server`): ENet на GAME_PORT, подключение к Steam
## через GodotSteam Server; каждый игрок должен пройти проверку билета аутентификации Steam.
## Клиент (GodotSteam): подключается через ENet, затем отправляет серверу билет аутентификации Steam.
## Используем Engine.get_singleton(), чтобы скрипт разбирался в экспортах, содержащих только одну из двух надстроек.

const STEAM_APP_ID := 480            # Spacewar, тестовое приложение Valve. Используйте собственный App ID.
const SERVER_VERSION := "1.0.0.0"    # x.x.x.x; Steam показывает только серверы с последней версией.
const GAME_PORT := 7777              # ENet, UDP. Порт Edgegap "gameport".
const QUERY_PORT := 27015            # Запросы Steam, UDP. Порт Edgegap "queryport".
const MAX_PLAYERS := 8
const AUTH_TIMEOUT_SEC := 15.0       # Отключаем участников, не отправивших действительный билет вовремя.
const NO_PLAYER_TIMEOUT_SEC := 120.0 # Останавливаем развёртывание, если никто не подключился.

# SteamServer.ServerMode и проверяемые результаты BeginAuthSession / AuthSession.
const SERVER_MODE_AUTHENTICATION := 2
const BEGIN_AUTH_RESULT_OK := 0
const AUTH_SESSION_RESPONSE_OK := 0

var steam_server: Object  # Синглтон SteamServer, только на сервере
var steam: Object         # Синглтон Steam, только на клиенте
var server_steam_id := 0
var players := {}         # peer_id -> steam_id, прошедшие аутентификацию игроки
var pending := {}         # peer_id -> {"steam_id": int, "deadline": float}
var had_players := false
var stopping := false


func _ready() -> void:
	if is_server_launch():
		_start_server()
	else:
		_start_client()


func _process(_delta: float) -> void:
	# Обратные вызовы Steam (сигналы) срабатывают только при вызове этой функции.
	if steam_server:
		steam_server.run_callbacks()
	if steam:
		steam.run_callbacks()
	if multiplayer.is_server() and steam_server:
		_check_timeouts()


static func is_server_launch() -> bool:
	return OS.has_feature("dedicated_server") or "--server" in OS.get_cmdline_user_args()


# ---------------------------------------------------------------- сервер

func _start_server() -> void:
	steam_server = Engine.get_singleton("SteamServer")
	if steam_server == null:
		_fail("Надстройка GodotSteam Server не загружена")
		return

	# Edgegap сопоставляет внутренние порты со случайными внешними. Steam объявляет игровой порт, который мы
	# передаём сюда, поэтому укажите внешний порт, к которому фактически подключаются игроки.
	var advertised_port := int(_env("ARBITRIUM_PORT_GAMEPORT_EXTERNAL", str(GAME_PORT)))
	var init: Dictionary = steam_server.serverInitEx("0.0.0.0", advertised_port, QUERY_PORT,
			SERVER_MODE_AUTHENTICATION, SERVER_VERSION)
	if init.get("status", -1) != 0:
		_fail("serverInitEx failed: %s" % init)
		return
	print("STEAM init ok game_port=%d query_port=%d" % [advertised_port, QUERY_PORT])

	steam_server.server_connected.connect(_on_steam_connected)
	steam_server.server_connect_failure.connect(_on_steam_connect_failure)
	steam_server.server_disconnected.connect(_on_steam_disconnected)
	steam_server.validate_auth_ticket_response.connect(_on_validate_auth_ticket_response)

	# Их нужно задать до входа в систему.
	steam_server.setModDir("spacewar")        # Имя папки вашей игры в Steam.
	steam_server.setProduct(str(STEAM_APP_ID))
	steam_server.setGameDescription("GodotSteam Server on Edgegap")
	steam_server.setDedicatedServer(true)
	steam_server.setMaxPlayerCount(MAX_PLAYERS)
	steam_server.setServerName("Edgegap %s" % _env("ARBITRIUM_REQUEST_ID", "local"))
	steam_server.setMapName("arena")

	var gslt := _env("STEAM_GSLT", "")
	if gslt.is_empty():
		steam_server.logOnAnonymous()
	else:
		steam_server.logOn(gslt)  # Постоянный Steam ID; требуется токен входа на игровой сервер.
	steam_server.setAdvertiseServerActive(true)

	var peer := ENetMultiplayerPeer.new()
	var err := peer.create_server(GAME_PORT, MAX_PLAYERS)
	if err != OK:
		_fail("ENet create_server failed: %s" % error_string(err))
		return
	multiplayer.multiplayer_peer = peer
	multiplayer.peer_connected.connect(_on_peer_connected)
	multiplayer.peer_disconnected.connect(_on_peer_disconnected)
	print("SERVER listening udp=%d request_id=%s" % [GAME_PORT, _env("ARBITRIUM_REQUEST_ID", "-")])
	get_tree().create_timer(NO_PLAYER_TIMEOUT_SEC).timeout.connect(func():
		if not had_players:
			_stop_server("nobody joined"))


func _on_steam_connected() -> void:
	server_steam_id = steam_server.getSteamID()
	var ip: Dictionary = steam_server.getPublicIP()
	print("STEAM logged on steam_id=%d public_ip=%s secure=%s" % [server_steam_id,
			_ip_to_string(ip.get("ipv4", 0)), steam_server.isServerSecure()])


func _on_steam_connect_failure(result: int, retrying: bool) -> void:
	print("STEAM connect failure result=%d retrying=%s" % [result, retrying])


func _on_steam_disconnected(result: int) -> void:
	print("STEAM disconnected result=%d" % result)


func _on_peer_connected(peer_id: int) -> void:
	pending[peer_id] = {"steam_id": 0, "deadline": Time.get_ticks_msec() / 1000.0 + AUTH_TIMEOUT_SEC}
	print("PEER connected peer=%d, waiting for Steam ticket" % peer_id)
	# Сообщаем клиенту, кто мы: он привязывает свой билет к Steam ID этого сервера.
	server_hello.rpc_id(peer_id, server_steam_id)


func _on_peer_disconnected(peer_id: int) -> void:
	pending.erase(peer_id)
	if players.has(peer_id):
		steam_server.endAuthSession(players[peer_id])
		players.erase(peer_id)
	print("PEER left peer=%d players=%d" % [peer_id, players.size()])
	if had_players and players.is_empty() and pending.is_empty():
		_stop_server("everyone left")


@rpc("any_peer", "reliable")
func submit_ticket(ticket: PackedByteArray, steam_id: int) -> void:
	if not multiplayer.is_server():
		return
	var peer_id := multiplayer.get_remote_sender_id()
	if not pending.has(peer_id):
		return
	var result: int = steam_server.beginAuthSession(ticket, ticket.size(), steam_id)
	print("AUTH begin peer=%d steam_id=%d result=%d" % [peer_id, steam_id, result])
	if result != BEGIN_AUTH_RESULT_OK:
		_kick(peer_id, "ticket rejected (%d)" % result)
		return
	pending[peer_id]["steam_id"] = steam_id
	# Steam отвечает вызовом validate_auth_ticket_response немного позже.


func _on_validate_auth_ticket_response(steam_id: int, response: int, owner_id: int) -> void:
	for peer_id in pending.keys():
		if pending[peer_id]["steam_id"] != steam_id:
			continue
		pending.erase(peer_id)
		if response != AUTH_SESSION_RESPONSE_OK:
			steam_server.endAuthSession(steam_id)
			_kick(peer_id, "Steam auth failed (%d)" % response)
			return
		players[peer_id] = steam_id
		had_players = true
		print("AUTH ok peer=%d steam_id=%d owner=%d players=%d" % [peer_id, steam_id, owner_id, players.size()])
		welcome.rpc_id(peer_id, players.size())
		return
	# Ответ для игрока, уже находящегося в игре, означает, что Steam завершил его сеанс (бан, вход с другого места).
	for peer_id in players.keys():
		if players[peer_id] == steam_id and response != AUTH_SESSION_RESPONSE_OK:
			_kick(peer_id, "Steam session ended (%d)" % response)


func _check_timeouts() -> void:
	var now := Time.get_ticks_msec() / 1000.0
	for peer_id in pending.keys():
		if now > pending[peer_id]["deadline"]:
			_kick(peer_id, "no Steam ticket")


func _kick(peer_id: int, reason: String) -> void:
	print("KICK peer=%d reason=%s" % [peer_id, reason])
	pending.erase(peer_id)
	multiplayer.multiplayer_peer.disconnect_peer(peer_id)


func _stop_server(reason: String) -> void:
	if stopping:
		return
	stopping = true
	print("SERVER stopping reason=%s" % reason)
	steam_server.setAdvertiseServerActive(false)
	steam_server.logOff()
	steam_server.serverShutdown()
	var url := _env("ARBITRIUM_DELETE_URL", "")
	if url.is_empty():
		get_tree().quit()
		return
	# Edgegap: удаляем собственное развёртывание, чтобы прекратить начисление платы.
	var http := HTTPRequest.new()
	add_child(http)
	http.request_completed.connect(func(result, code, _h, _b):
		print("SERVER self_stop result=%d http=%d" % [result, code])
		get_tree().quit())
	http.request(url, ["authorization: " + _env("ARBITRIUM_DELETE_TOKEN", "")], HTTPClient.METHOD_DELETE)


# ---------------------------------------------------------------- клиент

func _start_client() -> void:
	steam = Engine.get_singleton("Steam")
	if steam == null:
		_fail("Дополнение GodotSteam не загружено")
		return
	var init: Dictionary = steam.steamInitEx(STEAM_APP_ID)
	if init.get("status", -1) != 0:
		_fail("Не удалось инициализировать Steam. Steam запущен и выполнен вход? %s" % init)
		return
	print("CLIENT steam_id=%d name=%s" % [steam.getSteamID(), steam.getPersonaName()])

	var address := _arg("connect", "127.0.0.1:%d" % GAME_PORT)
	var host := address.get_slice(":", 0)
	var port := int(address.get_slice(":", 1))
	var peer := ENetMultiplayerPeer.new()
	var err := peer.create_client(host, port)
	if err != OK:
		_fail("Не удалось создать клиент ENet: %s" % error_string(err))
		return
	multiplayer.multiplayer_peer = peer
	multiplayer.connection_failed.connect(func(): _fail("не удалось подключиться к %s" % address))
	multiplayer.server_disconnected.connect(func(): _status("Сервер разорвал соединение"))
	_status("Подключение к %s..." % address)


@rpc("authority", "reliable")
func server_hello(steam_id_of_server: int) -> void:
	# Билет, привязанный к Steam ID этого сервера, нельзя повторно использовать для подключения к другому серверу.
	var ticket: Dictionary = steam.getAuthSessionTicket(steam_id_of_server)
	var bytes: PackedByteArray = ticket["buffer"].slice(0, ticket["size"])
	# Steam требуется немного времени, чтобы зарегистрировать билет: отправляем его после подтверждения от Steam.
	while true:
		var response: Array = await steam.get_auth_session_ticket_response
		if response[0] == ticket["id"]:
			if response[1] != 1:  # Результат Steam: OK
				_fail("Steam не удалось выдать билет (результат %d)" % response[1])
				return
			break
	_status("Подключение установлено. Отправка билета Steam (%d байт) серверу %d" % [bytes.size(), steam_id_of_server])
	submit_ticket.rpc_id(1, bytes, steam.getSteamID())


@rpc("authority", "reliable")
func welcome(player_count: int) -> void:
	_status("Аутентификация через Steam выполнена, игроков на сервере: %d" % player_count)
	if "--quit-after-auth" in OS.get_cmdline_user_args():
		await get_tree().create_timer(2.0).timeout
		get_tree().quit()


# ---------------------------------------------------------------- вспомогательные функции

func _status(text: String) -> void:
	print("CLIENT " + text)
	var label := get_tree().current_scene as Label
	if label:
		label.text = text


func _fail(text: String) -> void:
	push_error(text)
	print("ERROR " + text)
	if is_server_launch():
		get_tree().quit(1)
	else:
		_status(text)


static func _env(key: String, default: String) -> String:
	var value := OS.get_environment(key)
	return default if value.is_empty() else value


static func _arg(key: String, default: String) -> String:
	for a in OS.get_cmdline_user_args():
		if a.begins_with("--%s=" % key):
			return a.get_slice("=", 1)
	return default


static func _ip_to_string(ip: int) -> String:
	return "%d.%d.%d.%d" % [(ip >> 24) & 255, (ip >> 16) & 255, (ip >> 8) & 255, ip & 255]
```

{% endcode %}

☑️ Зарегистрируйте его как автозагрузку с именем `Session`, а также включите `flush_stdout_on_print` чтобы вывод серверного `print()` сразу попадал в журналы контейнера. В файле `project.godot`:

{% code title="project.godot" expandable="true" %}

```ini
[application]

run/flush_stdout_on_print=true

[autoload]

Session="*res://net/session.gd"
```

{% endcode %}

☑️ Когда будете готовы, замените заполнители собственными значениями: `STEAM_APP_ID`, `setModDir()`, `setGameDescription()` и `SERVER_VERSION`.

☑️ Проверьте работу из редактора: запустите проект с аргументом пользователя `--server` чтобы запустить сервер (Project Settings / Editor / Run / Main Run Args: `-- --server`), а затем запустите второй экземпляр с аргументом `-- --connect=127.0.0.1:7777` в качестве клиента. После проверки сервером билета клиент отобразит `AUTHENTICATED by Steam` .

✅ Теперь можно перейти к следующему шагу.

## 🐧 3. Экспорт сервера для Linux без графического интерфейса

Edgegap использует контейнеры Linux, поэтому сервер экспортируется для **Linux** в режиме Godot **Dedicated Server** : он запускается без графического интерфейса (без окна и GPU), а текстуры и аудио исключаются из экспорта.

☑️ Добавьте профиль экспорта с именем `Edgegap Linux Server` (Project / Export / Add / Linux) и задайте следующие параметры:

* **Режим экспорта** (вкладка Resources): экспортировать как выделенный сервер.
* **Фильтры для исключения файлов и папок**: `addons/godotsteam/*`, чтобы в экспорт сервера вошёл только GodotSteam Server.
* **Путь экспорта**: `build/edgegap-linux-server.x86_64`.
* **Встроить PCK**: выкл.

Или вставьте это в `export_presets.cfg` (измените номер `[preset.0]` если у вас уже есть пресеты):

{% code title="export\_presets.cfg" expandable="true" %}

```ini
[preset.0]

name="Edgegap Linux Server"
platform="Linux"
runnable=false
dedicated_server=true
custom_features=""
export_filter="customized"
customized_files={
"res://": "strip"
}
include_filter=""
exclude_filter="addons/godotsteam/*"
export_path="build/edgegap-linux-server.x86_64"
encryption_include_filters=""
encryption_exclude_filters=""
encrypt_pck=false
encrypt_directory=false
script_export_mode=2

[preset.0.options]

custom_template/debug=""
custom_template/release=""
debug/export_console_wrapper=0
binary_format/embed_pck=false
texture_format/s3tc_bptc=true
texture_format/etc2_astc=false
binary_format/architecture="x86_64"
```

{% endcode %}

☑️ Для пресетов клиентских сборок (Windows, macOS, Linux для настольных компьютеров) вместо этого исключите серверное дополнение: `addons/godotsteam_server/*`.

☑️ Соберите сервер через меню «Проект» / «Экспорт» или из командной строки:

```bash
mkdir -p build
godot --headless --path . --export-release "Edgegap Linux Server" build/edgegap-linux-server.x86_64
```

{% hint style="info" %}
Godot не создаёт папку для экспорта: перед экспортом убедитесь, что папка `build/` существует.
{% endhint %}

☑️ Проверьте `build` папку. Godot копирует GDExtension и библиотеку API Steamworks рядом с исполняемым файлом; серверу нужны все четыре файла:

```
build/
├─ edgegap-linux-server.x86_64
├─ edgegap-linux-server.pck
├─ libgodotsteam_server.linux.template_release.x86_64.so
└─ libsteam_api.so
```

{% hint style="info" %}
Имя и путь пресета совпадают с [плагином Godot для Edgegap](https://github.com/edgegap/buildtool-godot-plugin), поэтому кнопка **Экспортировать сервер** повторно использует этот пресет (она никогда не изменяет существующий пресет). Для шага **Создать контейнер** нужен Dockerfile из следующего шага: Dockerfile по умолчанию в плагине копирует только бинарный файл и `.pck`, но не файлы `.so` , необходимые серверу GodotSteam.
{% endhint %}

✅ Теперь можно перейти к следующему шагу.

## 🐋 4. Создайте контейнер для сервера

Игровому серверу Steam нужен файл, которого нет в экспорте: **`steamclient.so`**, клиентская библиотека Steam, которую API Steamworks загружает для связи со Steam. Valve распространяет её вместе с [SteamCMD](https://developer.valvesoftware.com/wiki/SteamCMD), а API Steamworks ищет её в каталоге `~/.steam/sdk64/`. Приведённый ниже Dockerfile загружает SteamCMD на первом этапе, копирует в итоговый образ только `steamclient.so` и запускает сервер от имени непривилегированного пользователя с помощью `tini`, поэтому при остановке развёртывания сервер завершается сразу.

☑️ Сохраните этот файл под именем `Dockerfile` в корне проекта:

{% code title="Dockerfile" lineNumbers="true" expandable="true" %}

```docker
# Этап 1: SteamCMD загружает steamclient.so. Серверу игры она нужна для входа в систему
# Steam; эта библиотека не входит в распространяемые компоненты Steamworks, поставляемые с GodotSteam.
FROM ubuntu:24.04 AS steamcmd
RUN apt-get update \
 && apt-get install -y --no-install-recommends ca-certificates curl lib32gcc-s1 \
 && rm -rf /var/lib/apt/lists/*
WORKDIR /steamcmd
RUN curl -fsSL https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz | tar -xz \
 && ./steamcmd.sh +quit \
 && test -f linux64/steamclient.so

# Этап 2: выделенный сервер Godot.
FROM ubuntu:24.04
# Тот же формат, что и у плагина Godot для Edgegap: путь относительно проекта без расширения.
ARG SERVER_BUILD_PATH=build/edgegap-linux-server

RUN apt-get update \
 && apt-get install -y --no-install-recommends ca-certificates tini \
 && rm -rf /var/lib/apt/lists/* \
 && useradd --create-home --uid 1001 game

# steam_api ищет 64-разрядную клиентскую библиотеку Steam в ~/.steam/sdk64/.
COPY --from=steamcmd --chown=game:game /steamcmd/linux64/steamclient.so /home/game/.steam/sdk64/steamclient.so

WORKDIR /home/game/server
COPY --chown=game:game ${SERVER_BUILD_PATH}.x86_64 ./server.x86_64
COPY --chown=game:game ${SERVER_BUILD_PATH}.pck ./server.pck
# GDExtension и библиотека API Steamworks, экспортированные рядом с бинарным файлом.
COPY --chown=game:game build/libgodotsteam_server.linux.template_*.x86_64.so build/libsteam_api.so ./
RUN chmod +x server.x86_64

# Ваш Steam App ID (480 = Spacewar, тестовое приложение Valve). То же самое, что файл steam_appid.txt.
ENV SteamAppId=480

USER game
# tini перенаправляет SIGTERM, поэтому при остановке развёртывания сервер завершается сразу.
ENTRYPOINT ["/usr/bin/tini", "--", "./server.x86_64"]
```

{% endcode %}

☑️ Добавьте рядом файл `.dockerignore` чтобы Docker не отправлял кэш Godot в сборку:

{% code title=".dockerignore" %}

```
.godot/
.git/
```

{% endcode %}

{% hint style="info" %}
Переменная окружения `SteamAppId` указывает API Steamworks, к какой игре относится этот сервер. Её можно переопределить для каждой версии приложения в Edgegap, не пересобирая образ.
{% endhint %}

☑️ Соберите образ. Укажите в теге временную метку, никогда не используйте `latest`:

```bash
docker build --platform linux/amd64 -t my-game-server:20261109-1924 .
```

☑️ Перед загрузкой проверьте образ локально:

```bash
docker run --name my-game-server -p 7777:7777/udp -p 27015:27015/udp my-game-server:20261109-1924
```

В журналах должно появиться сообщение о входе сервера в Steam:

```
[S_API] SteamAPI_Init(): Loaded '/home/game/.steam/sdk64/steamclient.so' OK.  (First tried local 'steamclient.so')
Setting breakpad minidump AppID = 480
STEAM init ok game_port=7777 query_port=27015
SERVER listening udp=7777 request_id=-
STEAM logged on steam_id=90297081554892826 public_ip=203.0.113.10 secure=false
```

{% hint style="info" %}
Строки `dlopen failed trying to load: steamclient.so` непосредственно перед строкой `Loaded '/home/game/.steam/sdk64/steamclient.so' OK` ожидаемы: API Steamworks сначала проверяет рабочую директорию.
{% endhint %}

☑️ Запустив Steam на своём компьютере, откройте клиент из проекта и подключитесь к контейнеру:

```bash
godot --path . -- --connect=127.0.0.1:7777
```

Клиент показывает `AUTHENTICATED by Steam, 1 player(s) on the server`, а в журнале сервера появляется `AUTH ok peer=... steam_id=...`. Закройте клиент: в журнале сервера появится `SERVER stopping reason=everyone left` и сервер завершит работу (локально удалять развёртывание не нужно).

✅ Теперь можно перейти к следующему шагу.

## ☁️ 5. Загрузка в Edgegap

☑️ Отправьте образ в [реестр контейнеров Edgegap](https://docs.edgegap.com/ru/learn/advanced-features/edgegap-container-registry.md). Название проекта, имя пользователя и токен можно найти на [странице реестра контейнеров](https://app.edgegap.com/registry-management/repositories/list) в панели управления:

```bash
echo "<registry-token>" | docker login registry.edgegap.com -u "<registry-username>" --password-stdin
docker tag my-game-server:20261109-1924 registry.edgegap.com/<project>/my-game-server:20261109-1924
docker push registry.edgegap.com/<project>/my-game-server:20261109-1924
```

☑️ [Создайте приложение](https://app.edgegap.com/application-management/applications/list), а затем [новую версию](https://docs.edgegap.com/ru/learn/orkestraciya/application-and-versions.md) на его основе с вашим образом и тегом, а также следующими портами:

| Имя порта   | Порт  | Протокол | Назначение                                                                                                                                      |
| ----------- | ----- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `gameport`  | 7777  | UDP      | Игровой трафик ENet. Игроки подключаются сюда.                                                                                                  |
| `queryport` | 27015 | UDP      | Запросы к серверу Steam (A2S). Необязательно, см. [#steam-server-browser](#steam-server-browser "mention"). Отключите проверку для этого порта. |

☑️ При необходимости добавьте переменные окружения версии:

* `SteamAppId` для переопределения App ID, встроенного в образ.
* `STEAM_GSLT` для токена входа на игровой сервер. По имени переменной понятно, что это секрет.

{% hint style="info" %}
Для этого скрипта вполне хватило 0,5 vCPU и 1 ГБ памяти. Подберите ресурсы для своей игры по метрикам контейнера в развертывании.
{% endhint %}

✅ Теперь можно перейти к следующему шагу.

## 🚀 6. Разверните сервер и подключите клиентов

☑️ Запустите развертывание новой версии из [панели управления](https://app.edgegap.com/deployment-management/deployments/list), выбрав расположение рядом с вами. Когда статус станет **Готово**, в логах контейнера появится информация о сервере в Steam:

```
STEAM init ok game_port=32137 query_port=27015
SERVER listening udp=7777 request_id=101ce07c06f7
STEAM logged on steam_id=90297081535503378 public_ip=192.46.222.253 secure=false
```

`game_port` — это **внешний** порт, который Edgegap сопоставил с портом 7777. Скрипт считывает его из внедренной переменной `ARBITRIUM_PORT_GAMEPORT_EXTERNAL` и передает Steam, чтобы тот объявлял адрес, доступный игрокам.

☑️ Подключите клиент к хосту развертывания и внешнему порту `gameport`:

```bash
godot --path . -- --connect=101ce07c06f7.pr.edgegap.net:32137
```

В логах клиента появится:

```
CLIENT Connecting to 101ce07c06f7.pr.edgegap.net:32137...
CLIENT Connected, sending Steam ticket (234 bytes) to server 90297081535503378
CLIENT AUTHENTICATED by Steam, 1 player(s) on the server
```

А в логах сервера:

```
PEER connected peer=1943168941, waiting for Steam ticket
AUTH begin peer=1943168941 steam_id=76561198040851267 result=0
AUTH ok peer=1943168941 steam_id=76561198040851267 owner=76561198040851267 players=1
```

☑️ Закройте клиент. Сервер выйдет из Steam и удалит собственное развертывание с помощью `ARBITRIUM_DELETE_URL`, поэтому развертывание завершится автоматически. Клиент, который исчез, не отключившись (например, из-за сбоя или потери соединения), будет удален после тайм-аута ENet (не более чем примерно через 30 секунд).

{% hint style="warning" %}
**Для работающей игры не подойдет ручной запуск развертываний и передача адресов через копирование и вставку.** Пусть [матчмейкер Edgegap](https://docs.edgegap.com/ru/learn/matchmeiking.md) запускает сервер и передаёт адрес каждому подобранному игроку, а проверку билета аутентификации Steam оставьте на сервере.
{% endhint %}

🙌 Поздравляем! Выделенный сервер GodotSteam Server работает на Edgegap!

## 👉 Следующие шаги

### Браузер серверов Steam

Браузер серверов Steam (`requestInternetServerList()` в GodotSteam или список серверов в клиенте Steam) **плохо подходит для развёртываний Edgegap**. Мы проверили: Steam отображает сервер с правильным адресом подключения (публичным IP-адресом и внешним игровым портом), но указывает внутренний порт запросов `27015`. Edgegap сопоставляет этот порт со случайным внешним портом, поэтому проверка связи Steam с сервером завершается по тайм-ауту, и сервер отображается как не отвечающий. На A2S-запросы, отправленные на внешний `queryport` развёртывания, сервер отвечает.

Чтобы направлять игроков на сервер, используйте один из следующих вариантов:

* [матчмейкер Edgegap](https://docs.edgegap.com/ru/learn/matchmeiking.md): игроки нажимают «Найти матч», Edgegap запускает сервер поблизости и передаёт его адрес каждому клиенту.
* Лобби Steam: когда сервер готов, лидер группы сохраняет его адрес в лобби с помощью `Steam.setLobbyGameServer()` или в данных лобби, а участники считывают адрес и подключаются.
* [браузер серверов Edgegap](https://docs.edgegap.com/ru/learn/brauzer-serverov.md) для постоянных серверов, которые игроки выбирают из списка.

### Учётная запись Steam и токен входа игрового сервера

`logOnAnonymous()` при каждом запуске присваивает серверу новый идентификатор Steam. Обычно так поступают с матчевыми серверами, работающими в течение одного сеанса; этого достаточно для проверки билета аутентификации.

Для постоянной идентификации сервера (например, чтобы игроки могли добавить его в избранное) понадобится [токен входа игрового сервера (GSLT)](https://steamcommunity.com/dev/managegameservers) и `logOn(token)`. Каждый токен может одновременно использоваться только одним работающим сервером, поэтому он подходит для нескольких постоянно работающих серверов, но не для отдельного развёртывания на каждый матч. Храните его в переменной версии `STEAM_GSLT` и никогда не добавляйте его в образ или репозиторий. В нашем тесте использовался только анонимный вход.

### Режимы аутентификации

`serverInitEx()` принимает режим сервера:

* `SERVER_MODE_NO_AUTHENTICATION` (1): проверка Steam не выполняется.
* `SERVER_MODE_AUTHENTICATION` (2): Steam проверяет билеты аутентификации. Используется в этом руководстве.
* `SERVER_MODE_AUTHENTICATION_AND_SECURE` (3): также включает VAC для приложений, в которых он поддерживается. `isServerSecure()` возвращает `true` после того, как Steam пометит сервер как защищённый.

### Устранение неполадок

<details>

<summary><code>Failed to retrieve non-existent singleton 'SteamServer'</code> или <code>GDExtension dynamic library not found</code></summary>

В экспортированной сборке сервера отсутствует `libgodotsteam_server.linux.template_*.x86_64.so`. Проверьте, что при экспорте файл был записан в `build/`и что Dockerfile копирует его рядом с исполняемым файлом. Стандартный Dockerfile плагина Edgegap Godot этого не делает: используйте Dockerfile из этого руководства.

</details>

<details>

<summary><code>serverInitEx failed</code> на сервере</summary>

* `steamclient.so` отсутствует в `~/.steam/sdk64/` пользователя, от имени которого запускается сервер. Сохраните этап SteamCMD, строку `COPY --from=steamcmd` и домашний каталог пользователя `USER game` , на который они указывают.
* App ID не задан: задайте `SteamAppId` (или добавьте файл `steam_appid.txt` с идентификатором рядом с исполняемым файлом).

</details>

<details>

<summary><code>Steam init failed, is Steam running and logged in?</code> на клиенте</summary>

На компьютере игрока должен быть запущен клиент Steam с выполненным входом в аккаунт, которому принадлежит App ID (App ID 480 доступен всем аккаунтам). При запуске через Steam App ID предоставляется самим Steam.

</details>

<details>

<summary>Клиент отключён с сообщением <code>Steam auth failed</code> или <code>ticket rejected</code></summary>

* `beginAuthSession` возвращает результат `1`: тикет недействителен. Отправляйте только первые `size` байт буфера тикета (`buffer.slice(0, size)`), а не весь буфер.
* `beginAuthSession` возвращает результат `2`: тикет для этого Steam ID уже используется, например, когда два клиента вошли в один и тот же аккаунт Steam.
* `validate_auth_ticket_response` возвращает ответ `2`: пользователю не принадлежит App ID. Проверьте, что клиент и сервер используют один и тот же App ID.

</details>

<details>

<summary>Клиент отключён с сообщением <code>no Steam ticket</code></summary>

Клиент не отправил тикет в течение `AUTH_TIMEOUT_SEC`. Проверьте вывод клиента на наличие ошибок Steam и убедитесь, что клиент ожидает `get_auth_session_ticket_response` прежде чем отправить тикет.

</details>

<details>

<summary>Журналы развёртывания пусты</summary>

Включите `application/run/flush_stdout_on_print` в настройках проекта. Без этого, `print()` вывод с headless-сервера остается в буфере.

</details>

<details>

<summary>Сервер отображается в Steam, но игроки не могут найти его в браузере серверов</summary>

Это ожидаемое поведение на Edgegap. См. [#steam-server-browser](#steam-server-browser "mention").

</details>

{% hint style="info" %}
Если вам нужна помощь, [свяжитесь с нами в Discord](https://discord.gg/MmJf8fWjnt). Для поддержки работающих игр воспользуйтесь нашей [системой тикетов](https://edgegap.atlassian.net/servicedesk/customer/portal/3).
{% endhint %}
