> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Exemplo Wrapper

> Use o exemplo Wrapper (wrappingGsdk) para executar um servidor de jogo Windows ou Linux existente no PlayFab Multiplayer Servers sem adicionar chamadas do GSDK ao seu binário.

O exemplo Wrapper, também conhecido como wrappingGsdk, encapsula um jogo existente para que ele possa ser usado na implantação de builds de servidores de jogo que usam o **sistema operacional Windows** e o **sistema operacional Linux**.

Usando o aplicativo wrapper, você também poderá usar o build do seu servidor de jogo no PlayFab Multiplayer Servers.

<Info>
  Um wrapper é uma solução alternativa que processa os fluxos de saída e de erro padrão para chamar os métodos do GSDK e não se destina ao uso em produção.
</Info>

## Conteúdo do exemplo

Este exemplo consiste em dois aplicativos de console .NET Core.

* Wrapper: integra o pacote NuGet mais recente do PlayFab Game Server SDK (GSDK) ao seu servidor de jogo. Este aplicativo wrapper **não se destina ao uso em produção**
* Fakegame: um servidor de jogo básico que não tem conhecimento do GSDK. É como um servidor de jogo típico que você teria antes de usar o PlayFab Multiplayer Servers. Ele inicia o servidor Web Kestrel do ASP.NET Core, que escuta na porta TCP 80. Ele se destina a simular um servidor de jogo que não tem absolutamente nenhum conhecimento do GSDK. Você pode usá-lo se não tiver um servidor de jogo próprio. Ele tem duas rotas GET que podemos usar: /hello, para obter uma resposta simples, e /hello/terminate, que pode encerrar o servidor.

## Requisitos

* [.NET Core 3.1 x64 SDK](https://dotnet.microsoft.com/download)

<Note>
  Para usar e ver o PlayFab Multiplayer Servers, você precisa habilitar o recurso no Game Manager. Para obter instruções, consulte [Habilitar o recurso PlayFab Server](/pt-BR/services/playfab/multiplayer/servers/enable-playfab-multiplayer-servers).
</Note>

## Passo a passo

Para um passo a passo ao vivo da criação deste exemplo, confira nossa apresentação do Microsoft Game Dev 2021 (começa em aproximadamente 2:52):

<iframe src="https://www.youtube.com/embed/kj2TcMlvWgk" width="100%" height="400" allowFullScreen frameBorder="0" />

<a id="acquire-and-build-wrapper-executable" />

## Obter e criar o executável do Wrapper

* Obtenha o [exemplo do wrapper do GSDK](https://github.com/PlayFab/MpsSamples/tree/master/wrappingGsdk) usando os métodos padrão do Git ou baixando-o como um arquivo zip
* Abra o Prompt de Comando e use o comando cd para alterar o caminho do diretório para o local do arquivo wrapper.csproj. Exemplo: **cd C:/ReplaceWithYourFilePath/wrappingGsdk/wrapper**
* Em seguida, execute o seguinte comando da CLI do .NET Core:

```
dotnet publish --self-contained -r win-x64 /p:PublishSingleFile=true /p:PublishTrimmed=true
```

Quando o build do wrapper for bem-sucedido, o executável será publicado na pasta ..\wrappingGsdk\wrapper\bin\Debug\netcoreapp3.1\win-x64\publish, conforme mostrado na imagem abaixo.

<img src="https://mintcdn.com/microsoft-4404708b/U1LR64ZWxo45eXwl/images/playfab/multiplayer/servers/create-your-first-server/wrapper-exe-location.PNG?fit=max&auto=format&n=U1LR64ZWxo45eXwl&q=85&s=1667c376bbaa6670b270d5264513278c" alt="Local de publicação do executável do wrapper" width="1615" height="365" data-path="images/playfab/multiplayer/servers/create-your-first-server/wrapper-exe-location.PNG" />

## Criar um ativo de servidor de jogo

Há duas maneiras de criar um ativo de servidor de jogo.

<a id="use-fakegame-game-server-with-the-wrapper" />

### Usar o servidor de jogo Fakegame com o wrapper

Use o build.ps1 para criar e empacotar os dois projetos (wrapper e fakegame). Esse script cria uma pasta de saída com um arquivo .zip que contém os arquivos necessários.

* Abra o PowerShell
* Use o comando cd para alterar o caminho do diretório para o local do script build.ps1. Exemplo: cd C:/ReplaceWithYourFilePath/wrappingGsdk/
* Execute **\build.ps1**
* Depois que o script for executado com êxito, vá para a pasta ..\wrappingGsdk\drop. Você encontrará um arquivo **gameassets.zip** criado, que contém o build do servidor de jogo falso, o executável do wrapper (criado na etapa anterior) e outros arquivos necessários.

### Usar os arquivos do seu próprio servidor de jogo com o wrapper

Para usar o projeto do seu jogo na avaliação, coloque o wrapper e o executável do seu servidor de jogo na mesma pasta.

* Siga as instruções em [Criar o executável do wrapper](#acquire-and-build-wrapper-executable)
* Vá para o local de publicação do wrapper em ..\wrappingGsdk\wrapper\bin\Debug\netcoreapp3.1\win-x64\publish
* Em outra janela, vá para o build do seu servidor de jogo e para os arquivos necessários para executá-lo. Se não tiver certeza de quais arquivos são necessários, consulte [Determinando os arquivos DLL necessários](/pt-BR/services/playfab/multiplayer/servers/determining-required-dlls)
* Copie o build do servidor de jogo e todos os arquivos necessários para o local de publicação do wrapper
* Selecione todos os arquivos no local de publicação do wrapper
* Com todos os arquivos selecionados, clique com o botão direito do mouse e selecione **Enviar para** > **Pasta compactada**. Não selecione a pasta de publicação do wrapper para adicioná-la ao zip. Isso causaria um mapeamento incorreto.

<Tip>
  Para conferir, siga as instruções em [Usar o servidor de jogo Fakegame com o wrapper](#use-fakegame-game-server-with-the-wrapper) para criar o gameassets.zip e usá-lo como referência.
</Tip>

## Criar e carregar uma imagem de contêiner Linux (somente para servidores Linux)

Para criar uma imagem de contêiner Linux, você precisaria de um Dockerfile. Um Dockerfile é um arquivo de texto sem extensão que contém todos os comandos necessários para criar uma determinada imagem de contêiner. Neste exemplo, esse arquivo já foi criado para você. Basta criar a imagem de contêiner e executá-la.

Se quiser usar seu dispositivo de desenvolvimento Windows, você precisará instalar o Subsistema do Windows para Linux (WSL). As instruções são fornecidas abaixo. Para obter mais informações, consulte [Diferenças entre imagens de contêiner Windows e Linux](/pt-BR/services/playfab/multiplayer/servers/deploying-linux-based-builds#windows-and-linux-container-image-differences).

1. [Configurar seu dispositivo de desenvolvimento Windows](/pt-BR/services/playfab/multiplayer/servers/deploying-linux-based-builds#set-up-your-windows-development-device) (opcional)
2. [Obter as credenciais de entrada do registro de contêiner do PlayFab](/pt-BR/services/playfab/multiplayer/servers/deploying-linux-based-builds#get-your-playfab-container-registry-sign-in-credentials)
3. Usar o Dockerfile existente/criar o seu próprio
   Esta etapa é diferente dependendo de você estar usando o FakeGame ou o seu próprio servidor de jogo.
   * Se estiver usando o FakeGame, verifique se você tem o [Dockerfile](https://github.com/PlayFab/MpsSamples/blob/master/wrappingGsdk/Dockerfile)
   * Se estiver usando o seu jogo ou precisar criar um Dockerfile, consulte [Criar seu Dockerfile](/pt-BR/services/playfab/multiplayer/servers/deploying-linux-based-builds#create-a-dockerfile). Você pode usar o [Dockerfile](https://github.com/PlayFab/MpsSamples/blob/master/wrappingGsdk/Dockerfile) do FakeGame como ponto de partida.
4. Abra seu terminal Linux com o Docker instalado, como o Ubuntu. Substitua os valores das variáveis TAG e ACR pelos seus valores. Em seguida, execute os comandos abaixo.

```docker theme={null}
TAG="0.1"
ACR="customer5555555.azurecr.io"
docker login ${ACR}
```

<Tip>
  Para verificar se as variáveis ACR e TAG estão definidas corretamente, execute **echo $ACR__ e __echo $TAG**.
</Tip>

5. Insira o nome de usuário e a senha obtidos na etapa anterior.
6. Crie e carregue a imagem de contêiner Linux.

Execute os comandos abaixo para criar e carregar o Dockerfile. Há um "." no final do comando **docker build**. Você precisa estar na mesma pasta/diretório do Dockerfile. Para obter detalhes, consulte [Criar e carregar a imagem de contêiner Linux](/pt-BR/services/playfab/multiplayer/servers/deploying-linux-based-builds#build-and-upload-linux-container-image).

```docker theme={null}
docker build -t ${ACR}/wrapper:${TAG} .
docker push ${ACR}/wrapper:${TAG}
```

## Implantar um build usando o Game Manager ou a API

O processo de implantação do build é semelhante para servidores de jogo Windows e Linux.

### Implantar servidores de jogo Windows

As etapas são semelhantes às do exemplo C# Windows Runner. Siga estas etapas, com as diferenças listadas abaixo.

* [Usar o Game Manager para implantar e configurar servidores](/pt-BR/services/playfab/multiplayer/servers/quickstart-for-multiplayer-servers-game-manager)
* [Usar PowerShell/API para implantar e configurar servidores](/pt-BR/services/playfab/multiplayer/servers/quickstart-for-multiplayer-servers-api-powershell)

Se preferir testar isso localmente, consulte [Depurando servidores de jogo localmente e integração com o PlayFab](/pt-BR/services/playfab/multiplayer/servers/locally-debugging-game-servers-and-integration-with-playfab).

**Configurações específicas deste exemplo**

* Comando de início:
  * Use **C:\Assets\wrapper.exe -g C:\Assets\fakegame.exe arg1 arg2**
  * Substitua fakegame.exe pelo nome do executável do seu servidor de jogo, se estiver usando o build do seu servidor de jogo
* Configuração de rede: Nome: **gameport**, Porta: **80**, Protocolo: **TCP**
* Ativos: ao usar o FakeGame, carregue **gameassets.zip** como ativo.

### Implantar servidores de jogo Linux

Siga as etapas gerais abaixo para implantar.

* [Usar o Game Manager para implantar e configurar servidores](/pt-BR/services/playfab/multiplayer/servers/deploy-using-game-manager)
* [Usar PowerShell/API para implantar e configurar servidores](/pt-BR/services/playfab/multiplayer/servers/deploy-using-powershell-api)

**Configurações específicas deste exemplo**

* Selecione o contêiner que você carregou
* Configuração de rede: Nome: **gameport**, Porta: **80**, Protocolo: **TCP**
* Não é necessário carregar ativos nem definir o **Start Command**

<Note>
  Durante a alocação com a API RequestMultiplayerServer, a porta à qual você se conecta será diferente de 80. Isso ocorre porque o serviço PlayFab Multiplayer Server criará um mapeamento entre o Azure Load Balancer (que expõe suas portas à Internet pública) e os servidores de jogo em execução nas máquinas virtuais do Azure.
</Note>

## Executando o wrapper usando o LocalMultiplayerAgent

O uso do LocalMultiplayerAgent é altamente recomendado se você quiser testar a integração do GSDK nos seus servidores de jogo personalizados.

Se você estiver usando o LocalMultiplayerAgent com contêineres Windows, precisará configurar corretamente o arquivo MultiplayerSettings.json. Você pode encontrar um exemplo abaixo; preste atenção especial aos valores de LocalFilePath e StartGameCommand. Não se esqueça de substituir fakegame.exe pelo nome do executável do seu servidor de jogo.

```json theme={null}
"AssetDetails": [
    {
        "MountPath": "C:\\Assets",
        "SasTokens": null,
        "LocalFilePath": "C:\\projects\\gsdkSamples\\wrappingGsdk\\drop\\gameassets.zip"
    }
],
"StartGameCommand": "C:\\Assets\\wrapper.exe -g C:\\Assets\\fakegame.exe",

// if you are using fakegameserver you should also configure port mapping for port 80
"PortMappingsList": [
            [
                {
                    "NodePort": 56100,
                    "GamePort": {
                        "Name": "gameport",
                        "Number": 80,
                        "Protocol": "TCP"
                    }
                }
            ]
        ]
```

Agora você está pronto para testar com o LocalMultiplayerAgent. Se você o configurou corretamente, assim que o LocalMultiplayerAgent iniciar seu servidor de jogo, você poderá se conectar a ele via curl em **[http://localhost:56100/Hello](http://localhost:56100/Hello)**.

## Como se conectar a um servidor de jogo no MPS

Para estabelecer uma conexão com um servidor de jogo no MPS, é essencial determinar o número de porta apropriado. Esse requisito decorre da configuração em que várias máquinas virtuais, cada uma possivelmente executando várias instâncias de servidor de jogo, são gerenciadas por trás de um balanceador de carga. Nessa configuração, uma única porta de IP público pode corresponder a portas diferentes nessas máquinas virtuais, cada uma associada a uma instância distinta de servidor de jogo.

### Usar o Game Manager

Você pode usar a interface do usuário do Game Manager para alocar um servidor de jogo e estabelecer uma conexão com ele.

1. Faça logon no Game Manager
2. Vá para a página Multiplayer => Servers e selecione seu build
3. Vá para a página Servers e clique no botão "Request server".
4. Na próxima página, anote o **endereço IPv4** público e a **Porta**.
5. Use o curl para se conectar em **http\://\[IPV4Address]:\[Ports->Num]/Hello**."

### Usar o exemplo MPS Allocator

Veja como você pode usar o [exemplo MPS Allocator](/pt-BR/services/playfab/multiplayer/servers/mps-allocator-sample) para alocar um servidor de jogo e estabelecer uma conexão com ele.

1. Compile e execute o exemplo MPS Allocator.
2. Use o comando "ListBuildSummaries" para ver os builds disponíveis e suas IDs de build correspondentes.
3. Invoque "RequestMultiplayerServer" para iniciar uma solicitação de uma instância de servidor de jogo.
4. Insira a ID de build selecionada no comando "ListMultiplayerServers" para gerar uma lista dos servidores disponíveis.
5. Escolha uma instância de servidor de jogo ativa e, em seguida, use "GetMultiplayerServerDetails" com as IDs de build e de sessão obtidas nas etapas anteriores.
6. Anote o **IPV4Address** e o **Ports->Num** exibidos na resposta.
7. Use o curl para se conectar em **http\://\[IPV4Address]:\[Ports->Num]/Hello**.

## Confira também

* [Criar seu primeiro servidor](/pt-BR/services/playfab/multiplayer/servers/create-your-first-server)
* [Recursos e exemplos](/pt-BR/services/playfab/multiplayer/servers/server-samples-resources)
* [SDKs do PlayFab Multiplayer Server](/pt-BR/services/playfab/multiplayer/servers/server-sdks/overview)
* [Referência de API](xref:titleid.playfabapi.com.multiplayer.multiplayerserver)


## Related topics

- [Criar seu primeiro servidor](/pt-BR/services/playfab/multiplayer/servers/create-your-first-server.md)
- [Implantar builds usando o Game Manager](/pt-BR/services/playfab/multiplayer/servers/deploy-using-game-manager.md)
- [Visão geral do LocalMultiplayerAgent](/pt-BR/services/playfab/multiplayer/servers/LocalMultiplayerAgent/local-multiplayer-agent-overview.md)
- [Implantar builds usando PowerShell/API](/pt-BR/services/playfab/multiplayer/servers/deploy-using-powershell-api.md)
- [Depurar servidores de jogo em contêiner com o LocalMultiplayerAgent](/pt-BR/services/playfab/multiplayer/servers/LocalMultiplayerAgent/run-container-gameserver.md)