> 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/fr/docs/sample-projects/godot/godotsteam-server.md).

# Serveur GodotSteam sur Edgegap

Serveur dédié GodotSteam sur Edgegap : export Linux sans interface graphique, connexion Steam et tickets d’authentification, Docker, déploiement et clients Steam.

[GodotSteam Server](https://codeberg.org/godotsteam/godotsteam-server) est la version dédiée aux serveurs de GodotSteam. Elle encapsule l’API de serveur de jeu de Steam (`SteamGameServer`) pour Godot, afin qu’un serveur sans interface graphique puisse se connecter à Steam, obtenir son propre identifiant Steam et vérifier que chaque joueur qui le rejoint est bien un utilisateur Steam possédant votre jeu.

Ce guide vous accompagne depuis un projet Godot vierge jusqu’à un serveur dédié GodotSteam Server exécuté sur Edgegap, auquel un client Steam se connecte et dont le ticket d’authentification Steam est validé. Les joueurs se connectent avec ENet, intégré à Godot (UDP) ; Steam sert à vérifier leur identité, la possession du jeu et les mesures anti-triche.

Le projet complet présenté dans ce guide est disponible sur GitHub : [edgegap/server-sample-godotsteam-dedicated-server](https://github.com/edgegap/server-sample-godotsteam-dedicated-server). Clonez-le, exécutez `./tools/fetch-godotsteam.sh` pour télécharger les modules complémentaires GodotSteam, puis suivez son fichier README pour lancer le serveur en quelques commandes.

{% hint style="success" %}
**Testé le 2026-11-09** avec Godot 4.7.2, GodotSteam Server 4.12.1 (GDExtension), GodotSteam 4.24 (GDExtension) et Steamworks SDK 1.65 : le serveur s’est connecté anonymement à Steam sur Edgegap, un client Windows s’est connecté via ENet, son ticket d’authentification a été validé par Steam et le déploiement s’est arrêté automatiquement au départ du client.
{% endhint %}

## ✔️ Préparation

Avant de commencer, veillez à [créer un compte gratuit sur Edgegap](https://app.edgegap.com/auth/register) (aucune carte bancaire requise).

**Configurez quelques éléments essentiels sur votre machine de développement :**

* [Godot 4.4 ou version ultérieure](https://godotengine.org/download) avec les modèles d’exportation **Linux** (Éditeur / Gérer les modèles d’exportation). La GDExtension de GodotSteam Server nécessite Godot 4.4 ou une version ultérieure.
* [Docker Desktop (ou Docker CLI)](https://www.docker.com/products/docker-desktop/).
* Le client Steam, installé et connecté, pour tester le client de votre jeu.
* Un ID d’application Steam. Ce guide utilise `480` (Spacewar), l’application de test de Valve accessible à tous les comptes Steam. Remplacez-la par votre propre ID d’application avant la publication.

{% hint style="info" %}
Vous débutez avec les serveurs dédiés dans Godot ? Commencez par [Godot - Prise en main](https://docs.edgegap.com/fr/godot.md) pour découvrir les étapes d’exportation, de configuration Docker et de déploiement avec le plug-in Edgegap, puis revenez ajouter Steam.
{% endhint %}

## 🧩 1. Installer GodotSteam

GodotSteam existe en deux versions, et un jeu client-serveur utilise les deux :

| Module complémentaire | Singleton     | Utilisé par   | Téléchargement                                                                                                                                                                                                                   |
| --------------------- | ------------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **GodotSteam Server** | `SteamServer` | Serveur dédié | [Versions sur Codeberg](https://codeberg.org/godotsteam/godotsteam-server/releases) (`godotsteam-server-<version>-gdextension-plugin-4.4.zip`), ou « GodotSteam Server GDExtension 4.4+ » dans la bibliothèque d’assets de Godot |
| **GodotSteam**        | `Steam`       | Client de jeu | [Versions sur Codeberg](https://codeberg.org/godotsteam/godotsteam/releases) (`godotsteam-<version>-gdextension-plugin-4.4.zip`), ou « GodotSteam GDExtension 4.4+ » dans la bibliothèque d’assets ou l’Asset Store de Godot     |

☑️ Décompressez les deux archives dans votre projet pour obtenir `addons/godotsteam_server/` et `addons/godotsteam/`. La bibliothèque de l’API Steamworks (`libsteam_api.so`, `steam_api64.dll`, ...) est déjà incluse dans chaque module complémentaire.

{% hint style="info" %}
**GDExtension ou module ?** Ce guide utilise les versions GDExtension : elles fonctionnent avec l’éditeur Godot standard et les modèles d’exportation standard. Les versions sous forme de module (`godotsteam-server` modèles et éditeur) nécessitent une version personnalisée de Godot ; si vous les utilisez, exportez le serveur avec les modèles GodotSteam Server et ignorez le dossier du module complémentaire. Ne mélangez jamais les versions GDExtension et module dans un même projet.
{% endhint %}

{% hint style="warning" %}
Lorsque les deux modules complémentaires sont présents dans un même projet, l’éditeur affiche des erreurs telles que `Attempt to register extension class 'SteamProjectSettings', which appears to be already registered`. Cette classe de paramètres est déclarée par les deux modules complémentaires. Lors de nos tests, cela n’a affecté ni le serveur ni le client, et chaque export de ce guide n’inclut qu’un seul des deux modules complémentaires ; les versions exportées ne rencontrent donc pas ce problème.
{% endhint %}

✅ Vous pouvez maintenant passer à l’étape suivante.

## 🔧 2. Ajouter le script du serveur et du client

Le script ci-dessous est un autoload qui s’exécute comme serveur dédié dans un export serveur et comme client partout ailleurs. Il utilise `Engine.get_singleton()` afin de rester analysable dans les exports qui n’incluent qu’un seul des deux modules complémentaires.

**Fonctionnement du serveur :**

1. `serverInitEx()` démarre l’API du serveur de jeu Steam avec le port de jeu, le port de requête, le mode d’authentification et la chaîne de version.
2. Définit le produit, la description, le répertoire du mod, le nom et le nombre de joueurs du serveur. Steam n’accepte ces valeurs qu’ **avant** la connexion.
3. `logOnAnonymous()` se connecte à Steam avec un identifiant Steam temporaire, ou `logOn(token)` avec un jeton de connexion au serveur de jeu lorsque `STEAM_GSLT` est défini (voir [#steam-account-and-game-server-login-token](#steam-account-and-game-server-login-token "mention")).
4. Ouvre un serveur ENet sur le port `7777`. Lorsqu’un pair se connecte, le serveur lui transmet son identifiant Steam et attend jusqu’à 15 secondes un ticket d’authentification Steam.
5. `beginAuthSession()` transmet le ticket à Steam ; le signal `validate_auth_ticket_response` indique si le joueur est autorisé. Les joueurs qui échouent à l’authentification ou n’envoient jamais de ticket sont déconnectés.
6. Lorsque tout le monde est parti (ou que personne ne s’est connecté en 2 minutes), le serveur se déconnecte de Steam et supprime son propre déploiement Edgegap, ce qui vous évite de payer pour un serveur vide.

**Fonctionnement du client :** initialise Steam avec votre App ID, se connecte avec ENet, demande à Steam un ticket de session d’authentification associé à l’identifiant Steam du serveur, attend la confirmation du ticket par Steam, puis l’envoie au serveur.

{% hint style="warning" %}
Les signaux Steam ne sont déclenchés que lorsque vous appelez `run_callbacks()`. Le script appelle `SteamServer.run_callbacks()` (et `Steam.run_callbacks()` côté client) à chaque image dans `_process`. Le paramètre de projet « embed callbacks » de GodotSteam s’accroche plutôt aux images de rendu, que le serveur sans interface graphique ne produit pas.
{% endhint %}

☑️ Enregistrez le script sous `res://net/session.gd`.

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

```gdscript
extends Node
## Un seul chargement automatique pour les deux côtés de la connexion.
## Serveur (export `dedicated_server` ou `-- --server`) : ENet sur GAME_PORT, connecté à Steam
## avec GodotSteam Server, et chaque joueur doit réussir une vérification de son ticket d’authentification Steam.
## Client (GodotSteam) : se connecte avec ENet, puis envoie un ticket d’authentification Steam au serveur.
## Utilise Engine.get_singleton() pour que le script puisse être analysé dans les exports qui n’intègrent qu’un seul des deux modules complémentaires.

const STEAM_APP_ID := 480            # Spacewar, l’application de test de Valve. Utilisez votre propre ID d’application.
const SERVER_VERSION := "1.0.0.0"    # x.x.x.x ; Steam ne répertorie que les serveurs exécutant la dernière version.
const GAME_PORT := 7777              # ENet, UDP. Port Edgegap « gameport ».
const QUERY_PORT := 27015            # Requêtes Steam, UDP. Port Edgegap « queryport ».
const MAX_PLAYERS := 8
const AUTH_TIMEOUT_SEC := 15.0       # Expulse les pairs qui n’envoient pas de ticket valide dans le délai imparti.
const NO_PLAYER_TIMEOUT_SEC := 120.0 # Arrête le déploiement si personne ne rejoint la partie.

# SteamServer.ServerMode et les résultats de BeginAuthSession / AuthSession que nous vérifions.
const SERVER_MODE_AUTHENTICATION := 2
const BEGIN_AUTH_RESULT_OK := 0
const AUTH_SESSION_RESPONSE_OK := 0

var steam_server: Object  # Singleton SteamServer, côté serveur uniquement
var steam: Object         # Singleton Steam, côté client uniquement
var server_steam_id := 0
var players := {}         # peer_id -> steam_id, joueurs authentifiés
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:
	# Les callbacks Steam (signaux) ne sont déclenchés que lorsque cette fonction est appelée.
	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()


# ---------------------------------------------------------------- serveur

func _start_server() -> void:
	steam_server = Engine.get_singleton("SteamServer")
	if steam_server == null:
		_fail("Module complémentaire GodotSteam Server non chargé")
		return

	# Edgegap associe les ports internes à des ports externes aléatoires. Steam annonce le port de jeu que nous
	# lui transmettons ici ; indiquez donc le port externe auquel les joueurs se connectent réellement.
	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)

	# À définir avant la connexion.
	steam_server.setModDir("spacewar")        # Le nom du dossier de votre jeu sur 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)  # Identifiant Steam persistant ; nécessite un jeton de connexion au serveur de jeu.
	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("personne n’a rejoint"))


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)
	# Indiquer au client qui nous sommes : il associe son ticket à l’identifiant Steam de ce serveur.
	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 répond avec validate_auth_ticket_response un peu plus tard.


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
	# Une réponse concernant un joueur déjà dans la partie signifie que Steam a mis fin à sa session (bannissement, connexion depuis un autre endroit).
	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 : supprimer notre propre déploiement pour arrêter la facturation.
	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)


# ---------------------------------------------------------------- client

func _start_client() -> void:
	steam = Engine.get_singleton("Steam")
	if steam == null:
		_fail("GodotSteam add-on not loaded")
		return
	var init: Dictionary = steam.steamInitEx(STEAM_APP_ID)
	if init.get("status", -1) != 0:
		_fail("Steam init failed, is Steam running and logged in? %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 create_client failed: %s" % error_string(err))
		return
	multiplayer.multiplayer_peer = peer
	multiplayer.connection_failed.connect(func(): _fail("could not reach %s" % address))
	multiplayer.server_disconnected.connect(func(): _status("Déconnecté par le serveur"))
	_status("Connexion à %s..." % address)


@rpc("authority", "reliable")
func server_hello(steam_id_of_server: int) -> void:
	# Un ticket lié à l'ID Steam de ce serveur ne peut pas être réutilisé auprès d'un autre serveur.
	var ticket: Dictionary = steam.getAuthSessionTicket(steam_id_of_server)
	var bytes: PackedByteArray = ticket["buffer"].slice(0, ticket["size"])
	# Steam a besoin d'un instant pour enregistrer le ticket : l'envoyer une fois que Steam l'a confirmé.
	while true:
		var response: Array = await steam.get_auth_session_ticket_response
		if response[0] == ticket["id"]:
			if response[1] != 1:  # Résultat Steam OK
				_fail("Steam n'a pas pu émettre de ticket (résultat %d)" % response[1])
				return
			break
	_status("Connecté, envoi du ticket Steam (%d octets) au serveur %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("Authentifié par Steam, %d joueur(s) sur le serveur" % player_count)
	if "--quit-after-auth" in OS.get_cmdline_user_args():
		await get_tree().create_timer(2.0).timeout
		get_tree().quit()


# ---------------------------------------------------------------- utilitaires

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 %}

☑️ Enregistrez-le comme autoload sous le nom `Session`, et activez `flush_stdout_on_print` pour que la sortie de `print()` du serveur apparaisse immédiatement dans les journaux du conteneur. Dans `project.godot`:

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

```ini
[application]

run/flush_stdout_on_print=true

[autoload]

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

{% endcode %}

☑️ Remplacez les valeurs fictives par les vôtres lorsque vous serez prêt : `STEAM_APP_ID`, `setModDir()`, `setGameDescription()` et `SERVER_VERSION`.

☑️ Testez depuis l’éditeur : lancez le projet avec `--server` comme argument utilisateur pour démarrer un serveur (Paramètres du projet / Éditeur / Exécution / Arguments d’exécution principaux : `-- --server`), puis lancez une deuxième instance avec `-- --connect=127.0.0.1:7777` comme client. Le client affiche `AUTHENTICATED by Steam` une fois que le serveur a validé son ticket.

✅ Vous pouvez maintenant passer à l’étape suivante.

## 🐧 3. Exporter le serveur Linux sans interface

Edgegap exécute des conteneurs Linux ; le serveur est donc exporté pour **Linux** en mode **Dedicated Server** de Godot : il démarre sans interface (sans fenêtre ni GPU) et exclut les textures et l’audio de l’exportation.

☑️ Ajoutez un préréglage d’exportation nommé `Edgegap Linux Server` (Projet / Exportation / Ajouter / Linux), puis définissez :

* **Mode d’exportation** (onglet Ressources) : exporter en tant que serveur dédié.
* **Filtres pour exclure des fichiers/dossiers**: `addons/godotsteam/*`, afin que l’exportation du serveur n’inclue que GodotSteam Server.
* **Chemin d’exportation**: `build/edgegap-linux-server.x86_64`.
* **Intégrer le PCK**: désactivé.

Ou collez ceci dans `export_presets.cfg` (renumérotez `[preset.0]` si vous avez déjà des préréglages) :

{% 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 %}

☑️ Pour vos préréglages client (Windows, macOS, Linux de bureau), excluez plutôt l’extension complémentaire du serveur : `addons/godotsteam_server/*`.

☑️ Exportez le serveur depuis Projet / Exporter, ou depuis la ligne de commande :

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

{% hint style="info" %}
Godot ne crée pas le dossier d’exportation : assurez-vous que `build/` existe avant l’exportation.
{% endhint %}

☑️ Vérifiez le dossier `build` Godot copie l’extension GDExtension et la bibliothèque de l’API Steamworks à côté du binaire, et le serveur a besoin des quatre fichiers :

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

{% hint style="info" %}
Le nom et le chemin du préréglage correspondent à ceux du [module complémentaire Godot Edgegap](https://github.com/edgegap/buildtool-godot-plugin), donc son bouton **Exporter le serveur** réutilise ce préréglage (il ne modifie jamais un préréglage existant). Son étape **Conteneuriser** nécessite le Dockerfile de l’étape suivante : le Dockerfile par défaut du module complémentaire ne copie que le binaire et le `.pck`, pas les fichiers `.so` dont GodotSteam Server a besoin.
{% endhint %}

✅ Vous pouvez maintenant passer à l’étape suivante.

## 🐋 4. Conteneuriser le serveur

Un serveur de jeu Steam a besoin d’un fichier qui ne figure pas dans votre export : **`steamclient.so`**, la bibliothèque cliente Steam chargée par l’API Steamworks pour communiquer avec Steam. Valve la distribue avec [SteamCMD](https://developer.valvesoftware.com/wiki/SteamCMD), et l’API Steamworks la recherche dans `~/.steam/sdk64/`. Le Dockerfile ci-dessous télécharge SteamCMD dans une première étape, puis ne copie que `steamclient.so` dans l’image finale et exécute le serveur sous un utilisateur non root avec `tini`, afin que l’arrêt du déploiement mette immédiatement fin au serveur.

☑️ Enregistrez ce fichier sous le nom `Dockerfile` à la racine de votre projet :

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

```docker
# Étape 1 : SteamCMD télécharge steamclient.so. Le serveur de jeu en a besoin pour se connecter à
# Steam, et ce fichier ne fait pas partie des redistribuables Steamworks fournis avec 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

# Étape 2 : le serveur dédié Godot.
FROM ubuntu:24.04
# Même convention que celle du module complémentaire Godot Edgegap : chemin relatif au projet, sans extension.
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 recherche la bibliothèque cliente Steam 64 bits dans ~/.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
# L’extension GDExtension et la bibliothèque de l’API Steamworks, exportées à côté du binaire.
COPY --chown=game:game build/libgodotsteam_server.linux.template_*.x86_64.so build/libsteam_api.so ./
RUN chmod +x server.x86_64

# Votre ID d’application Steam (480 = Spacewar, l’application de test de Valve). Même effet que steam_appid.txt.
ENV SteamAppId=480

USER game
# tini transmet SIGTERM ; l’arrêt du déploiement arrête donc immédiatement le serveur.
ENTRYPOINT ["/usr/bin/tini", "--", "./server.x86_64"]
```

{% endcode %}

☑️ Ajoutez un `.dockerignore` à côté, afin que Docker n’envoie pas le cache de Godot lors de la compilation :

{% code title=".dockerignore" %}

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

{% endcode %}

{% hint style="info" %}
La `SteamAppId` variable d’environnement indique à l’API Steamworks à quel jeu ce serveur appartient. Vous pouvez la remplacer pour chaque version de l’application sur Edgegap au lieu de reconstruire l’image.
{% endhint %}

☑️ Compilez l’image. Attribuez-lui un tag avec un horodatage, jamais `latest`:

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

☑️ Testez-la localement avant de la téléverser :

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

Les journaux devraient montrer que le serveur se connecte à 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" %}
Les lignes `dlopen failed trying to load: steamclient.so` juste avant `Loaded '/home/game/.steam/sdk64/steamclient.so' OK` sont attendues : l’API Steamworks commence par essayer le répertoire de travail.
{% endhint %}

☑️ Pendant que Steam est lancé sur votre machine, démarrez un client depuis votre projet et connectez-vous au conteneur :

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

Le client affiche `AUTHENTICATED by Steam, 1 player(s) on the server`, et le serveur consigne `AUTH ok peer=... steam_id=...`. Fermez le client : le serveur consigne `SERVER stopping reason=everyone left` et s’arrête (en local, aucun déploiement à supprimer).

✅ Vous pouvez maintenant passer à l’étape suivante.

## ☁️ 5. Téléverser sur Edgegap

☑️ Envoyez votre image vers le [registre de conteneurs d’Edgegap](https://docs.edgegap.com/fr/learn/advanced-features/edgegap-container-registry.md). Retrouvez le nom de votre projet, votre nom d’utilisateur et votre jeton sur la [page Container Registry](https://app.edgegap.com/registry-management/repositories/list) du tableau de bord :

```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
```

☑️ [Créer une application](https://app.edgegap.com/application-management/applications/list), puis une [nouvelle version](https://docs.edgegap.com/fr/learn/orchestration/application-and-versions.md) avec votre image et votre tag, ainsi que les ports suivants :

| Nom du port | Port  | Protocole | Utilisation                                                                                                                               |
| ----------- | ----- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `gameport`  | 7777  | UDP       | Trafic de jeu ENet. Les joueurs se connectent ici.                                                                                        |
| `queryport` | 27015 | UDP       | Requêtes des serveurs Steam (A2S). Facultatif, voir [#steam-server-browser](#steam-server-browser "mention"). Désactivez sa vérification. |

☑️ Ajoutez éventuellement des variables d’environnement de version :

* `SteamAppId` pour remplacer l’ID d’application intégré à l’image.
* `STEAM_GSLT` pour un jeton de connexion au serveur de jeu. Son nom indique qu’il s’agit d’un secret.

{% hint style="info" %}
0,5 vCPU et 1 Go de mémoire suffisaient amplement pour ce script. Adaptez les ressources à votre jeu à l’aide des métriques de conteneur du déploiement.
{% endhint %}

✅ Vous pouvez maintenant passer à l’étape suivante.

## 🚀 6. Déployer et connecter les clients

☑️ Lancez un déploiement de votre nouvelle version depuis le [tableau de bord](https://app.edgegap.com/deployment-management/deployments/list), près de votre emplacement. Une fois qu’il est **Prêt**, les journaux de son conteneur affichent le serveur sur 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` est le port **externe** qu’Edgegap associe au port 7777. Le script le récupère depuis la variable injectée `ARBITRIUM_PORT_GAMEPORT_EXTERNAL` et le transmet à Steam, afin que Steam annonce l’adresse à laquelle les joueurs peuvent réellement accéder.

☑️ Connectez un client à l’hôte du déploiement et au port externe de `gameport`:

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

Les journaux du client :

```
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
```

Et ceux du serveur :

```
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
```

☑️ Fermez le client. Le serveur se déconnecte de Steam et supprime son propre déploiement via `ARBITRIUM_DELETE_URL`, ce qui met fin automatiquement au déploiement. Un client qui disparaît sans se déconnecter (plantage, perte de connexion) est supprimé lorsque ENet détecte son délai d’expiration (jusqu’à environ 30 secondes).

{% hint style="warning" %}
**Lancer manuellement des déploiements et copier-coller des adresses ne suffira pas pour un jeu en production.** Laissez le [système de matchmaking Edgegap](https://docs.edgegap.com/fr/learn/matchmaking.md) démarrer le serveur et transmettre son adresse à chaque client trouvé, tout en conservant la vérification du ticket d’authentification Steam côté serveur.
{% endhint %}

🙌 Félicitations, votre serveur dédié GodotSteam Server fonctionne sur Edgegap !

## 👉 Étapes suivantes

### Navigateur de serveurs Steam

Le navigateur de serveurs de Steam (`requestInternetServerList()` dans GodotSteam, ou la liste des serveurs dans le client Steam) ne **convient pas aux déploiements Edgegap**. Nous l’avons testé : Steam répertorie le serveur avec la bonne adresse de connexion (IP publique et port de jeu externe), mais enregistre le port de requête comme port interne `27015`. Edgegap associe ce port à un port externe aléatoire. Les pings de Steam vers le serveur expirent donc et celui-ci apparaît comme ne répondant pas. Les requêtes A2S envoyées au port externe `queryport` du déploiement reçoivent bien une réponse.

Utilisez plutôt l’une de ces méthodes pour diriger les joueurs vers un serveur :

* [Système de matchmaking Edgegap](https://docs.edgegap.com/fr/learn/matchmaking.md) : les joueurs cliquent sur « Trouver une partie », Edgegap démarre un serveur à proximité et transmet son adresse à chaque client.
* Salons Steam : une fois le serveur prêt, le salon du chef de groupe stocke son adresse avec `Steam.setLobbyGameServer()` ou dans les données du salon, que les membres lisent pour le rejoindre.
* [Navigateur de serveurs Edgegap](https://docs.edgegap.com/fr/learn/navigateur-de-serveurs.md)  : pour les serveurs persistants que les joueurs choisissent dans une liste.

### Compte Steam et jeton de connexion au serveur de jeu

`logOnAnonymous()` attribue un nouvel identifiant Steam au serveur à chaque démarrage. C’est le choix habituel pour les serveurs de parties qui ne durent qu’une session, et cela suffit pour la vérification du ticket d’authentification.

Une identité de serveur persistante (par exemple, pour permettre aux joueurs d’ajouter un serveur à leurs favoris) nécessite un [jeton de connexion au serveur de jeu (GSLT)](https://steamcommunity.com/dev/managegameservers) et `logOn(token)`. Chaque jeton ne peut être utilisé que par un seul serveur actif à la fois : cette méthode convient donc à quelques serveurs de longue durée, mais pas à un déploiement par partie. Stockez-le dans la variable `STEAM_GSLT` , jamais dans l’image ni dans votre dépôt. Notre test utilisait uniquement la connexion anonyme.

### Modes d’authentification

`serverInitEx()` prend le mode du serveur en paramètre :

* `SERVER_MODE_NO_AUTHENTICATION`  (1) : aucune vérification Steam.
* `SERVER_MODE_AUTHENTICATION`  (2) : Steam valide les tickets d’authentification. Ce mode est utilisé dans ce guide.
* `SERVER_MODE_AUTHENTICATION_AND_SECURE`  (3) : active également VAC pour les applications où VAC est activé. `isServerSecure()` renvoie `true` une fois que Steam a déclaré le serveur sécurisé.

### Dépannage

<details>

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

L’export du serveur est manquant `libgodotsteam_server.linux.template_*.x86_64.so`. Vérifiez que l’export l’a écrit dans `build/`, et que votre Dockerfile le copie à côté du binaire. Le Dockerfile par défaut du plugin Godot d’Edgegap ne le fait pas : utilisez le Dockerfile de ce guide.

</details>

<details>

<summary><code>serverInitEx failed</code> sur le serveur</summary>

* `steamclient.so` est absent de `~/.steam/sdk64/` de l’utilisateur qui exécute le serveur. Conservez l’étape SteamCMD et la ligne `COPY --from=steamcmd` ainsi que le répertoire personnel vers lequel pointe `USER game` .
* Pas d’App ID : définissez `SteamAppId` (ou ajoutez un fichier `steam_appid.txt` contenant l’ID à côté du binaire).

</details>

<details>

<summary><code>Steam init failed, is Steam running and logged in?</code> sur le client</summary>

Le client Steam doit être en cours d’exécution et connecté sur la machine du joueur, et le compte doit posséder l’App ID (tous les comptes peuvent utiliser 480). Si le jeu est lancé via Steam, l’App ID provient directement de Steam.

</details>

<details>

<summary>Le client est expulsé avec le message <code>Steam auth failed</code> ou <code>ticket rejected</code></summary>

* `Résultat de` l’appel `1`: le ticket n’est pas valide. Envoyez uniquement les premiers `size` octets du tampon du ticket (`buffer.slice(0, size)`), et non le tampon entier.
* `Résultat de` l’appel `2`: un ticket associé à cet ID Steam est déjà utilisé, par exemple lorsque deux clients sont connectés au même compte Steam.
* `Réponse de` validate\_auth\_ticket\_response `2`: l’utilisateur ne possède pas l’App ID. Vérifiez que le client et le serveur utilisent le même App ID.

</details>

<details>

<summary>Le client est expulsé avec le message <code>no Steam ticket</code></summary>

Le client n’a pas envoyé son ticket dans le délai `AUTH_TIMEOUT_SEC`. Vérifiez la sortie du client pour repérer d’éventuelles erreurs Steam et assurez-vous que le client attend `get_auth_session_ticket_response` avant d’envoyer le ticket.

</details>

<details>

<summary>Les journaux de déploiement sont vides</summary>

Activez `application/run/flush_stdout_on_print` dans les paramètres du projet. Sans cela, `print()` la sortie d’un serveur sans interface reste mise en mémoire tampon.

</details>

<details>

<summary>Le serveur apparaît dans Steam, mais les joueurs ne le trouvent pas dans le navigateur de serveurs</summary>

Comportement attendu sur Edgegap, voir [#steam-server-browser](#steam-server-browser "mention").

</details>

{% hint style="info" %}
Si vous avez besoin d’aide, [veuillez nous contacter sur Discord](https://discord.gg/MmJf8fWjnt). Pour obtenir de l’aide concernant les jeux en direct, consultez notre [système de tickets](https://edgegap.atlassian.net/servicedesk/customer/portal/3).
{% endhint %}
