DEV Community: Magno Gouveia

Como eu criei um servidor de PalWorld na AWS com start por bot no Discord — Parte 2

Magno Gouveia — Sat, 27 Jan 2024 20:50:05 +0000

Na primeira parte, ensinei como criar uma máquina virtual na AWS e instalar um servidor de Palworld. Porém, ainda precisamos resolver a questão da máquina ficar ligada o tempo todo, uma forma de permitir que qualquer pessoa inicie o servidor a partir do Discord e também ter acesso ao IP do server.

Desligando a máquina automaticamente:

Para automatizar a desativação do servidor, decidi criar um script que:

Verifica se o servidor está iniciado.
Verifica se há jogadores
Desliga a máquina caso não haja mais jogadores.

Para isso, vamos criar um script chamado: shutdownServer.sh com o conteúdo abaixo:

#!/bin/bash

cd /home/ubuntu/palworld

# Execute o comando para obter a lista de jogadores e capturar possíveis erros
OUTPUT=$(docker-compose run --rm rcon ShowPlayers 2>&1)

# Filtra linhas indesejadas
CLEANED_OUTPUT=$(echo "$OUTPUT" | grep -v "Creating palworld_rcon_run")

# Verifica se ocorreu um erro na execução do comando
if echo "$CLEANED_OUTPUT" | grep -q "ERROR"; then
    echo "Erro ao executar o comando. Possivelmente, máquina está ligando."
    STOP_INSTANCE=false
else
    # Conta o número de jogadores
    NUM_PLAYERS=$(echo "$CLEANED_OUTPUT" | wc -l)
    NUM_PLAYERS=$((NUM_PLAYERS-1)) # Ajusta para subtrair o cabeçalho, se houver

    if [ "$NUM_PLAYERS" -le 0 ]; then
        echo "Nenhum jogador online."
        STOP_INSTANCE=true
    else
        echo "Há $NUM_PLAYERS jogadores online."
        echo "Lista de Jogadores:"
        echo "$CLEANED_OUTPUT" | cut -d ',' -f 1
        STOP_INSTANCE=false
    fi
fi

# Se não houver jogadores online ou ocorreu um erro, parar o container do Docker e desligar a máquina
if [ "$STOP_INSTANCE" = true ]; then
    # Encontra o ID do container que está executando a imagem especificada
    CONTAINER_ID=$(docker ps -q --filter ancestor=jammsen/palworld-dedicated-server:latest)

    # Verifica se um container foi encontrado
    if [ -n "$CONTAINER_ID" ]; then
        echo "Parando o container do Docker: $CONTAINER_ID"
        docker stop $CONTAINER_ID
    else
        echo "Nenhum container encontrado para a imagem especificada."
    fi

    echo "Desligando a máquina..."
    sudo shutdown -h now
fi

Aqui estamos usando o programa rcon para obter uma lista de jogadores online e armazenando em OUTPUT.

Quando a máquina está iniciando, geralmente esse comando retorna um ERROR; neste caso, não vamos desligar a máquina.

Após isso, se houverem jogadores online, nós exibimos uma lista com os nomes, e caso não haja ninguém, o servidor irá desligar o Docker e após isso, desligar a própria máquina.

Depois de criar o script, dê permissões de execução com o comando:

$ chmod +x shutdownServer.sh

Agora vamos criar um repetidor, para executar o script de 30 em 30 minutos:

Execute o seguinte comando como sudo:

$ sudo crontab -e

Vá até o final do arquivo e adicione a linha:

*/30 * * * * /home/ubuntu/palworld/shutdownServer.sh >> /home/ubuntu/logs/log_$(date +\%Y_\%m_\%d_\%H_\%M).log 2>&1

Com isso, o servidor irá executar o script de 30 em 30 minutos e guardar os logs na pasta “logs” na home. O script precisa ser executado como sudo para ter acesso a parar o container do Docker e também desligar a máquina.

Crie a pasta para guardar os logs:

$ mkdir /home/ubuntu/logs

Criando sua função lambda

Antes de criar o bot propriamente dito, precisamos criar as funções que serão executadas por ele.

No seu console da AWS, procure pelo serviço “Lambda”
Crie uma nova função no botão superior direito
Dê um nome como “discord-lambda”
Escolha a linguagem “Node.js 20.x”
Clique em “Criar Função” no canto inferior direito.

Precisamos chamar um “gatilho” que irá executar essa Lambda quando um endereço for chamado, para isso:

Na “Visão geral da função”
Clique em “+ Adicionar gatilho”
Selecione API Gateway
Selecione “Create a new API”
Em “API type” Selecione “HTTP API”
Em Security Selecione “Open”
Abra a aba “Additional Settings”
Selecione a opção “Cross-origin resource sharing (CORS)”

(isso irá permitir o discord chamar sua função mesmo de outro domínio.)

Clique em “Adicionar”
Na aba “Configuração>Gatilhos” acesse o endereço “API endpoint”
Se abrir uma nova aba com o texto: “Hello from Lambda!”, tudo deu certo até então.
Copie esse endereço, vamos utilizá-lo mais tarde na criação do bot.
Com sua função criada, vamos baixar o código desse repositório: https://github.com/andarilhoz/discord-lambda
Dentro dele, acesse a pasta “aws” e execute o comando npm install para instalar a dependência tweetnacl que irá ler o request do discord.
Adicione todo conteúdo de dentro da pasta “aws” (incluindo o node_modules) para um arquivo .zip
No seu navegador, na lambda recém criada dentro da aba “Código” clique em “Fazer upload de” e escolha “Arquivo .zip”
Faça o upload do zip criado anteriormente
Na aba “Configuração” selecione “Variáveis de ambiente” e preencha as seguintes variáveis:

AWS_ECS_REGION -> a região da sua ecs, se você criou em São Paulo, será: "sa-east-1" (https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html)
INSTANCE_ID -> O id da sua instancia EC2 criada no artigo passado
CHANNEL_ID -> O id do canal do seu servidor do discord onde o bot irá funcionar
ROLE_ID -> O id do cargo que terá permissão para executar os comandos
PUBLIC_KEY -> Será gerado mais a frente quando criarmos o bot no discord

Essa lambda também requer permissão para executar scripts do EC2 **e **AWS Cost Explorer Service

No menu Configuração, selecione o sub-menu “Permissões”
Embaixo da label “Nome da função” clique no link com o nome [sua-lambda]-role-[id], isso abrirá o gerenciador de permissões da AWS
Selecione a Politica de Permissões criada automaticamente (terá um suffixo: AWSLambdaBasicExecutionRole)
Clique em “Editar”

Adicione a seguinte permissão no json, dentro da propriedade “Statement”:

    {
      "Sid": "AccessCostExplorer",
      "Effect": "Allow",
      "Action": [
        "ce:GetCostAndUsage",
        "ec2:DescribeInstances",
        "ec2:StartInstances",
        "ec2:StopInstances"
      ],
      "Resource": "*"
    }

Isso dará a lambda permissões para:

Ver o custo e uso de seus serviços na AWS
Descrever uma instancia EC2
Iniciar uma instancia EC2
Pausar uma instancia EC2

Clique em “Próximo” e depois em “Salvar Alterações”.

Após salvar as permissões, só falta adicionarmos o PUBLIC_KEY que iremos gerar agora no Discord para finalizar a lambda.

Criando um bot no Discord

Abra o Developer Portal do discord,

Crie uma nova aplicação, e dê um nome.
Na aba “General Information” copie o “PUBLIC KEY” e adicione esse valor na variável da lambda criada no passo anterior.
Ainda em “General Information” preencha o campo “INTERACTIONS ENDPOINT URL” com a url da sua lambda criada no passo anterior.
Clique em “Save Changes”
Você deverá ver a mensagem: “All your edits have been carefully recorded.”
Vá na aba “OAuth2 > URL Generator”
Em “SCOPES” selecione “bot”
Em “BOT PERMISSIONS” selecione “Use Slash Commands”
Copie a URL gerada na parte de baixo, e use-a para adicionar o seu novo bot no servidor desejado.
Na aba “Bot” clique no botão “Reset Token”
Copie o código gerado que iremos utilizar no próximo passo.
Na aba “General Information” copie o código “APPLICATION ID” que também será necessário.

Adicionando comandos do bot:

Com o repositório clonado anteriormente acesse a pasta: “discord”
Crie um arquivo .env e preencha as variáveis de ambiente:

BOT_TOKEN=ODUwMTk2NDDyMDc2MjgyOTAw.GpYcOB.q2XSa_IUw5A3sHId67s6kQzSoiZP_zfZFCyDvE //O Token Gerado anteriormente na aba "Bot" do discord
APP_ID=850196442076282900 //O App Id gerado anteriormente na aba "General Information"
GUILD_ID=337788789500449762 //O ID do seu servidor do discord.

Execute o comando npm install na pasta “discord”
Execute o comando node addcommand.js

Se tudo ocorreu bem, você verá essas mensagens:

success
200
success
200
success
200
success
200
All commands sent

Pronto! agora você pode executar os comandos do seu bot no seu servidor para iniciar o EC2, pausar, ver o status (e IP) e também ver o custo total de EC2 da sua aplicação.

Adicionando um IP Elástico

Um dos problemas de se ligar e desligar um servidor EC2 é que seu ip acaba mudando constantemente, vamos adicionar um IP Elástico que não irá mudar.

No seu console da AWS, busque por EC2
No menu esquerdo selecione “IPs elásticos”
Clique em “Alocar endereço de IP elástico”
Clique em **“Alocar” **no canto inferior direito
Agora selecione o IP na lista de endereços
Clique em “Ações” no botão direito superior
Clique em “Associar endereço IP elástico”
Abaixo da label “Instância” selecione seu servidor EC2
Clique em “Associar” no canto direito inferior.

Pronto, esse IP será fixo e será o ip permanente da sua máquina, e não mudara mesmo após desligá-la.

Conclusão

Como dito anteriormente, a máquina t3a.xlarge custaria mensalmente $170 USD, com essa alteração, considerando que você e seus amigos joguem cerca de 4 horas por dia, todos os dias, esse valor cai para: $29 USD. Existem outras maneiras de baratear esse custo, já que é uma máquina que tem capacidade para 32 jogadores simultâneos. Você pode testar máquinas com uma memória menor para 4 jogadores por exemplo.

Dessa forma, com a máquina t3a.xlarge, economizamos em um mês $141 USD, quase $700 Reais!

Daqui pra frente:

Um dos problemas dessa configuração é o “cold start” da lambda AWS, você pode transformar a lambda em um servidor EC2 nano, que além de garantir o baixo custo, sempre estará disponível!

Como eu criei um servidor de PalWorld na AWS com start por bot no Discord

Magno Gouveia — Sat, 27 Jan 2024 20:49:46 +0000

É difícil não ter ouvido sobre Palworld recentemente, com o sucesso explosivo e mais de 8 milhões de vendas.

Queria jogar com meus amigos e ter um servidor sempre disponível, independente de um de nós hostear. Isso pareceu uma ótima oportunidade para brincar um pouco com a AWS.

Cheguei a testar alguns outros servidores, como Nitrado, mas a falta de servidor no Brasil, quedas constantes e também pouco controle de acesso ao servidor, me fizeram optar por criar o meu próprio servidor em um serviço de cloud privado, como já trabalho com AWS há alguns anos, não tive duvidas e comecei a criar a infra.

Aqui vou mostrar como fiz cada passo.

Criação de um servidor EC2

EC2 é o serviço da AWS para criar “máquinas na cloud”, ao criar uma, a primeira coisa para ter em mente é o tamanho do servidor.

Dentro do console da Aws, busque pelo serviço: EC2.
No canto esquerdo no menu, selecione Instâncias
No canto superior direito, clique em “Executar Instâncias”

Nome e tags

Dê um nome para sua instância (eg: PalworldServer)

Application and OS Images (Amazon Machine Image)

Neste guia vamos escolher o sistema operacional Ubuntu 22.04 (64bits x86)

Tipo de instância

Pelas configurações ideais dadas pelos desenvolvedores, a maquina deveria ter:

16gb de Ram
4 núcleos de processamento

Optei então pela maquina mais barata que atendesse esses requisitos: t3a.xlarge.

(Você pode buscar o tipo da maquina por configuração na calculadora da aws ))

Selecione o tipo de instância (t3a.xlarge)

Par de chaves (login)

Crie uma par de chaves para fazer o login por ssh:
nesse exemplo, vou chamar de palworld-sao-paulo.pem
Tipo: RSA
Formato: .pem
Criar par de chaves

Configurações de Rede

Neste momento não é necessário fazer nenhuma mudança aqui, mas vamos voltar para essa configuração depois de criar a máquina, só lembre de deixar marcado a opção:

“Allow SSH traffic from” — “Qualquer lugar” (Só será possível acessar a maquina usando o arquivo .pem criado anteriormente.)

Configurar armazenamento

1x de 20gb gp2 é o suficiente para um servidor, na minha experiência o servidor usa menos de 7gb, mas gosto de deixar espaço para alguma emergência.

(Obs: Não recomendo tentar usar uma instancia spot, mesmo sendo mais barato, a instabilidade de disponibilidade quebra todo o conceito de ter um servidor para jogar com os amigos na hora que você quiser.

Se isso não é um problema pra você e souber o que está fazendo, é uma opção.)

Configuração inicial da maquina linux

Pronto! você tem uma instancia linux preparada para uso, agora vamos configurá-la

No console da aws em EC2>Instâncias copie o “Endereço IPv4 público”
Usando um terminal (cmd/bash) conecte-se no endereço com o seguinte comando:

$ ssh -i [/endereco/da/chave/palworld-sao-paulo.pem] ubuntu@[seu-endereço-ip]

Com isso você já tem a maquina preparada para receber o servidor, vamos utilizar essa imagem docker-compose:

https://github.com/jammsen/docker-palworld-dedicated-server

na home do seu servidor (/home/ubuntu) crie uma pasta palworld

$ mkdir palworld

dentro da pasta palworld, crie uma pasta chamada “game”

$ mkdir game

Dê permissões de acesso para a pasta game:

$ chmod 777 game 
      ou 
$ chown -R 1000:1000 game/

Crie um arquivo de configuração chamado docker-compose.yml e cole o exemplo abaixo (retirado do github):

 version: '3.9'
    services:
      palworld-dedicated-server:
        #build: .
        container_name: palworld-dedicated-server
        image: jammsen/palworld-dedicated-server:latest
        restart: always
        network_mode: bridge
        ports:
          - target: 8211 # Gamerserver port inside of the container
            published: 8211 # Gamerserver port on your host
            protocol: udp
            mode: host
          - target: 25575 # RCON port inside of the container
            published: 25575 # RCON port on your host
            protocol: tcp
            mode: host
        environment:
          - TZ=Europe/Berlin # Change this for logging and backup, see "Environment-Variables" 
          - ALWAYS_UPDATE_ON_START=true
          - MULTITHREAD_ENABLED=true
          - COMMUNITY_SERVER=true
          - BACKUP_ENABLED=true
          - BACKUP_CRON_EXPRESSION=0 * * * *
          - NETSERVERMAXTICKRATE=120
          - DIFFICULTY=None
          - DAYTIME_SPEEDRATE=1.000000
          - NIGHTTIME_SPEEDRATE=1.000000
          - EXP_RATE=1.000000
          - PAL_CAPTURE_RATE=1.000000
          - PAL_SPAWN_NUM_RATE=1.000000
          - PAL_DAMAGE_RATE_ATTACK=1.000000
          - PAL_DAMAGE_RATE_DEFENSE=1.000000
          - PLAYER_DAMAGE_RATE_ATTACK=1.000000
          - PLAYER_DAMAGE_RATE_DEFENSE=1.000000
          - PLAYER_STOMACH_DECREASE_RATE=1.000000
          - PLAYER_STAMINA_DECREACE_RATE=1.000000
          - PLAYER_AUTO_HP_REGENE_RATE=1.000000
          - PLAYER_AUTO_HP_REGENE_RATE_IN_SLEEP=1.000000
          - PAL_STOMACH_DECREACE_RATE=1.000000
          - PAL_STAMINA_DECREACE_RATE=1.000000
          - PAL_AUTO_HP_REGENE_RATE=1.000000
          - PAL_AUTO_HP_REGENE_RATE_IN_SLEEP=1.000000
          - BUILD_OBJECT_DAMAGE_RATE=1.000000
          - BUILD_OBJECT_DETERIORATION_DAMAGE_RATE=1.000000
          - COLLECTION_DROP_RATE=1.000000
          - COLLECTION_OBJECT_HP_RATE=1.000000
          - COLLECTION_OBJECT_RESPAWN_SPEED_RATE=1.000000
          - ENEMY_DROP_ITEM_RATE=1.000000
          - DEATH_PENALTY=All
          - ENABLE_PLAYER_TO_PLAYER_DAMAGE=false
          - ENABLE_FRIENDLY_FIRE=false
          - ENABLE_INVADER_ENEMY=true
          - ACTIVE_UNKO=false
          - ENABLE_AIM_ASSIST_PAD=true
          - ENABLE_AIM_ASSIST_KEYBOARD=false
          - DROP_ITEM_MAX_NUM=3000
          - DROP_ITEM_MAX_NUM_UNKO=100
          - BASE_CAMP_MAX_NUM=128
          - BASE_CAMP_WORKER_MAXNUM=15
          - DROP_ITEM_ALIVE_MAX_HOURS=1.000000 
          - AUTO_RESET_GUILD_NO_ONLINE_PLAYERS=false
          - AUTO_RESET_GUILD_TIME_NO_ONLINE_PLAYERS=72.000000
          - GUILD_PLAYER_MAX_NUM=20
          - PAL_EGG_DEFAULT_HATCHING_TIME=72.000000
          - WORK_SPEED_RATE=1.000000 
          - IS_MULTIPLAY=false
          - IS_PVP=false
          - CAN_PICKUP_OTHER_GUILD_DEATH_PENALTY_DROP=false
          - ENABLE_NON_LOGIN_PENALTY=true
          - ENABLE_FAST_TRAVEL=true
          - IS_START_LOCATION_SELECT_BY_MAP=true
          - EXIST_PLAYER_AFTER_LOGOUT=false
          - ENABLE_DEFENSE_OTHER_GUILD_PLAYER=false
          - COOP_PLAYER_MAX_NUM=4
          - MAX_PLAYERS=32
          - SERVER_NAME=jammsen-docker-generated-###RANDOM###
          - SERVER_DESCRIPTION=Palworld-Dedicated-Server running in Docker by jammsen
          - ADMIN_PASSWORD=adminPasswordHere
          - SERVER_PASSWORD=serverPasswordHere
          - PUBLIC_PORT=8211
          - PUBLIC_IP=
          - RCON_ENABLED=false
          - RCON_PORT=25575
          - REGION=
          - USEAUTH=true
          - BAN_LIST_URL=https://api.palworldgame.com/api/banlist.txt
        volumes:
          - ./game:/palworld

      rcon:
        image: outdead/rcon:latest
        entrypoint: ['/rcon', '-a', '10.0.0.5:25575', '-p', 'adminPasswordHere']
        profiles: ['rcon']

Lembre-se de alterar o arquivo de acordo com o seu servidor.

Após a criação do docker-compose.yml, execute o docker-compose:

$ sudo docker-compose up -d

Você pode acompanhar os logs com: $ sudo docker-compose logs -f
Após algum tempo o container irá baixar a steam, o servidor, fazer o login anonimamente e servir o jogo na porta: 8211

Vamos liberar o acesso a essa porta na aws:

No console da aws no serviço EC2, selecione “security groups”
Clique no security group atrelado a sua maquina (provavelmente launch-wizard-1)
Clique em “Regras de saída”
Clique em “Editar Regras de saída”
Clique em “Adicionar Regra”
Selecione o Tipo: “UDP Personalizado”
Intervalo de portas: 8211
Destino: Qualquer Local — IPv4

Com isso já será possível se conectar com o jogo na sua máquina.

Porém temos alguns problemas:

Sem um IP estático, toda vez que a maquina reiniciar, o IP de acesso público irá mudar
Só é possível iniciar a máquina pelo painel da AWS
A maquina ficará ligada 24/7 a menos que você a desligue manualmente pelo console da AWS.

Com essa configuração, os custos não são otimizados, e a máquina ligada 24/7 terá um custo aproximado de: $170USD por mês.

Vou criar uma parte 2 explicando como resolver cada um desses problemas, diminuir drasticamente os custos e como facilitar seu acesso, criando um bot no discord vinculado com a AWS!