One place for hosting & domains

      August 2020

      Como criar um bot no Discord com o Node.js


      O autor selecionou o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Discord é um aplicativo de chat que permite a milhões de usuários em todo o mundo enviar mensagens e bate-papo de voz online em comunidades chamadas guilds ou servidores. O Discord também fornece uma extensa API que os desenvolvedores podem usar para criar poderosos bots no Discord. Os bots podem realizar várias ações, como enviar mensagens para servidores, enviar mensagens diretas a usuários, moderar servidores e reproduzir áudio em conversas de voz. Isso permite que desenvolvedores criem robôs poderosos que incluem recursos avançados e complexos, como ferramentas de moderação ou até mesmo jogos. Por exemplo, o bot utilitário Dyno serve milhões de guilds e contém recursos úteis, como proteção contra spam, um reprodutor de música e outras funções utilitárias. Aprender como criar bots no Discord lhe permite implementar muitas possibilidades, com as quais milhares de pessoas poderiam interagir todos os dias.

      Neste tutorial, você irá criar um bot Discord a partir do zero, usando o Node.js e a biblioteca Discord.js, que permite aos usuários interagir diretamente com a API do Discord. Você irá configurar um perfil para um bot do Discord, obter tokens de autenticação para o bot, e programá-lo com a capacidade de processar comandos, com argumentos, dos usuários.

      Pré-requisitos

      Antes de começar, você precisará do seguinte:

      Passo 1 — Configurando um bot Discord

      Neste passo você usará a GUI de desenvolvedores do Discord para configurar um bot Discord e obter o token do bot, que você passará para o seu programa.

      Para registrar um bot na plataforma Discord, use o painel da aplicação Discord. Aqui os desenvolvedores podem criar aplicações Discord, incluindo bots Discord.

      Image of the Discord application dashboard after first visiting https://discord.com/developers/applications

      Para começar, clique em New Application. O Discord vai lhe pedir que digite um nome para a sua nova aplicação. Em seguida, clique em Create para criar a aplicação.

      Image of the prompt to create an application, with

      Nota: o nome para sua aplicação é independente do nome do bot, e o bot não precisa ter o mesmo nome que a aplicação.

      Agora, abra seu painel de aplicação. Para adicionar um bot à aplicação, navegue até a guia Bot na barra de navegação à esquerda.

      Image of the bot tab of the application dashboard

      Clique no botão Add Bot para adicionar um bot à aplicação. Clique no botão Yes, do it! quando ele lhe pedir confirmação. Você estará então em um painel contendo detalhes do nome do seu bot, token de autenticação e foto do perfil.

      Dashboard containing details of your bot

      Você pode modificar o nome do seu bot ou a imagem do perfil aqui no painel. Você também precisa copiar o token de autenticação do bot, clicando em Click to Reveal Token e copiando o token que aparece.

      Atenção: nunca compartilhe ou faça o upload do seu token do bot, pois ele permite que alguém faça login no seu bot.

      Agora, você precisa criar um convite que lhe permita adicionar as guilds do bot Discord onde você pode testar o bot. Primeiro, navegue até a guia OAuth2 do painel da aplicação. Para criar um convite, desça e selecione bot abaixo de scopes Você também deve definir permissões para controlar quais ações o seu bot pode realizar nas guilds. Para os propósitos deste tutorial, selecione Administrator, que dará ao seu bot permissão para realizar quase todas as ações nas guilds. Copie o link com o botão Copy.

      OAuth2 tab, with scope set to

      Em seguida, adicione o bot a um servidor. Siga o link do convite que você acabou de criar. Você pode adicionar o bot a qualquer servidor que você possua, ou que tenha permissões de administrador, a partir do menu suspenso.

      Page from following the invite link, allowing users to add the bot to servers

      Agora, clique em Continue. Certifique-se de que a caixa de seleção ao lado de Administrator esteja assinalada — isso concederá ao bot permissões de administrador. Em seguida, clique em Authorize. O Discord irá lhe pedir que resolva um CAPTCHA antes que o bot se junte ao servidor. Agora, você terá o bot Discord na lista de membros no servidor que você adicionou o bot, abaixo de offline.

      Members list of a Discord server with the newly created bot under the

      Você criou com sucesso um bot Discord e o adicionou a um servidor. Em seguida, você irá escrever um programa para fazer login no bot.

      Passo 2 — Criando o seu projeto

      Neste passo, você irá configurar o ambiente de codificação básico onde você irá criar seu bot e fazer login nele programaticamente.

      Primeiro, você precisa configurar uma pasta de projeto e os arquivos de projeto necessários para o bot.

      Crie sua pasta de projeto:

      Vá para a pasta do projeto que você acabou de criar:

      Em seguida, use seu editor de texto para criar um arquivo chamado config.json para armazenar o token de autenticação do seu bot:

      Em seguida, adicione o seguinte código ao arquivo de configuração, substituindo o texto destacado pelo token de autenticação do seu bot:

      config.json

      {
          "BOT_TOKEN": "YOUR BOT TOKEN"
      }
      

      Salve e saia do arquivo.

      Em seguida, você irá criar um arquivo package.json, que irá armazenar detalhes do seu projeto e informações sobre as dependências que você usará para o projeto. Você irá criar um arquivo package.json executando o seguinte comando npm:

      O npm irá lhe perguntar vários detalhes sobre seu projeto. Se você quiser orientação sobre como preencher esses prompts, pode ler sobre eles em How To Use Node.js Modules with npm and package.json.

      Agora, você irá instalar o pacote discord.js que você usará para interagir com a API do Discord. Você pode instalar discord.js através do npm com o seguinte comando:

      Agora que você definiu o arquivo de configuração e instalou a dependência necessária, você está pronto para começar a criar seu bot. Em uma aplicação no mundo real, um bot grande seria dividido em muitos arquivos, mas para os fins deste tutorial, o código para o bot estará em um único arquivo.

      Primeiro, crie um arquivo chamado index.js na pasta discord-bot para o código:

      Comece a codificação do bot exigindo a dependência discord.js e o arquivo de configuração com o token do bot:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      

      Após isso, adicione as duas linhas de código seguintes:

      index.js

      ...
      const client = new Discord.Client();
      
      client.login(config.BOT_TOKEN);
      

      Salve e saia do seu arquivo.

      A primeira linha de código cria um novo Discord.Client e o atribui à constante client. Este cliente, em parte, é como você irá interagir com a API do Discord e como o Discord irá notificá-lo de eventos como novas mensagens. O client e, na verdade, representa o bot Discord.

      A segunda linha de código usa o método login no client para fazer login no bot Discord que você criou, usando o token no arquivo config.json como uma senha. O token permite que a API do Discord saiba a qual bot o programa se destina e que você está autenticado para usar o bot.

      Agora, execute o arquivo index.js usando o Node:

      O status do seu bot irá se alterar para online no servidor Discord ao qual você o adicionou.

      Image of the bot online

      Você criou com sucesso um ambiente de codificação e criou o código básico para fazer login em um bot Discord. No próximo passo, você irá lidar com comandos de usuário e fazer com que seu bot execute ações, como o envio de mensagens.

      Neste passo, você irá criar um bot que possa lidar com comandos de usuário. Você irá implementar seu primeiro comando ping, que irá responder com "pong" e o tempo necessário para responder ao comando.

      Primeiro, você precisa detectar e receber quaisquer mensagens que os usuários enviam para que você possa processar quaisquer comandos. Usando o método on no cliente Discord, o Discord irá lhe enviar uma notificação sobre novos eventos. O método on leva dois argumentos: o nome de um evento para esperar e uma função a executar cada vez que esse evento ocorre. Com este método, você pode esperar pelo evento message — isso ocorrerá cada vez que uma mensagem for enviada a uma guild onde o bot tiver a permissão para visualizar mensagens. Portanto, vamos criar uma função que será executada cada vez que uma mensagem for enviada, para processar comandos.

      Primeiro abra seu arquivo:

      Adicione o código a seguir ao seu arquivo:

      index.js

      ...
      const client = new Discord.Client();
      
      
      client.on("message", function(message) { 
                                               
      });                                      
      
      client.login(config.BOT_TOKEN);
      

      Essa função, que executa no evento message, toma message como um parâmetro. message terá o valor de uma instância Discord.js message, que contém informações sobre a mensagem enviada e os métodos para ajudar o bot a responder.

      Agora, adicione a seguinte linha de código à sua função de tratamento de comandos:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
      });
      ...
      

      Essa linha verifica se o autor da mensagem é um bot e, se assim for, para de processar o comando. Isso é importante, pois geralmente você não quer processar ou responder a mensagens de bots. Os bots geralmente não precisam ou não querem usar nosso bot, portanto, ignorar suas mensagens economiza energia de processamento e ajuda a evitar respostas acidentais.

      Agora, você irá escrever um handler de comando. Para realizar isso, é bom entender o formato usual de um comando Discord. Normalmente, a estrutura de um comando Discord contém três partes na seguinte ordem: um prefixo, um nome de comando e, às vezes, argumentos de comando.

      An image of a typical Discord command reading

      • Prefix: o prefixo pode ser qualquer coisa, mas normalmente é um pedaço de pontuação ou frase abstrata que normalmente não estaria no início de uma mensagem. Isso significa que quando você incluir o prefixo no início da mensagem, o bot irá saber que a intenção para este comando é para um bot processá-lo.

      • Command name: o nome do comando que o usuário quer usar. Isso significa que o bot pode suportar vários comandos com diferentes funcionalidades e permitir aos usuários escolher entre eles fornecendo um nome de comando diferente.

      • Arguments: às vezes, se o comando exigir ou usar informações extras do usuário, o usuário pode fornecer argumentos após o nome do comando, com cada argumento separado por um espaço.

      Nota: não há nenhuma estrutura de comando obrigatória, e os bots podem processar comandos como eles quiserem, mas a estrutura aqui apresentada é uma estrutura eficiente que a grande maioria dos bots usam.

      Para começar a criar um parser de comando que lida com este formato, adicione as seguintes linhas de código à função de tratamento de mensagens:

      index.js

      ...
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      });
      ...
      

      Você adiciona a primeira linha de código para atribuir o valor "!" à constante prefix, que você usará como o prefixo do bot.

      A segunda linha de código que você adiciona , verifica se o conteúdo da mensagem que o bot está processando começa com o prefixo que você definiu e, se não começar, interrompe o processamento da mensagem.

      Agora, converta o resto da mensagem em um nome de comando e todos os argumentos da mensagem. Adicione as linhas destacadas a seguir:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      });
      ...
      

      Você usa a primeira linha aqui para remover o prefixo do conteúdo da mensagem e atribuir o resultado à constante commandBody. Isso é necessário, uma vez que você não quer incluir o prefixo no nome de comando no qual você fez a varredura.

      A segunda linha pega a mensagem com o prefixo removido e usa o método split nela, com um espaço como separador. Isso a divide em um array de sub-strings, fazendo uma divisão onde quer que haja um espaço. Isso resulta em um array contendo o nome do comando e, se incluído na mensagem, quaisquer argumentos. Você atribui este array à constante args.

      A terceira linha remove o primeiro elemento do array args (que será o nome de comando fornecido), o converte em minúsculas e, em seguida, o atribui à constante command. Isso lhe permite isolar o nome do comando e deixar apenas argumentos no array. Você também usa o método toLowerCase, pois os comandos normalmente não diferenciam maiúsculas de minúsculas em bots do Discord.

      Você concluiu a construção de um parser de comando, implementando um prefixo necessário e obtendo o nome do comando e quaisquer argumentos das mensagens. Agora, você irá implementar e criar o código para os comandos específicos.

      Adicione o código a seguir para iniciar a implementação do comando ping:

      index.js

      ...
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
                                 
        }                        
      });
      ...
      

      Esta declaração if verifica se o nome de comando que você analisou (atribuído à constante command) corresponde ao "ping". Se sim, isso indica que o usuário quer usar o comando "ping". Você irá aninhar o código para o comando específico dentro do bloco da declaração if. Você irá repetir este padrão para outros comandos que você deseja implementar.

      Agora, você pode implementar o código para o comando "ping":

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      ...
      

      Salve e saia do seu arquivo.

      Você adiciona o bloco do comando "ping" que calcula a diferença entre o tempo atual — encontrado usando o método now no objeto Date — e o timestamp de quando a mensagem foi criada em milisegundos. Isso calcula quanto tempo a mensagem levou para processar o "ping" do bot.

      A segunda linha responde ao comando do usuário usando o método reply na constante message. O método reply faz um ping (que notifica o usuário e destaca a mensagem para o usuário especificado) no usuário que invocou o comando, seguido pelo conteúdo fornecido como o primeiro argumento para o método. Você fornece um modelo literal contendo uma mensagem e o ping calculado como a resposta que o método reply usará.

      Isso conclui a implementação do comando "ping".

      Execute seu bot usando o comando a seguir (na mesma pasta que index.js):

      Agora, use o comando "! ping"“ em qualquer canal onde o bot possa visualizar e enviar mensagens, resultando em uma resposta.

      Image of bot replying in Discord to

      Você criou com sucesso um bot que pode lidar com comandos de usuário e implementou seu primeiro comando. No próximo passo, você irá continuar desenvolvendo seu bot implementando um comando sum.

      Passo 4 — Implementando o comando Sum

      Agora, você irá estender seu programa implementando o comando "! sum". O comando irá tomar qualquer número de argumentos e adicioná-los juntos, antes de retornar a soma de todos os argumentos ao usuário.

      Se seu bot Discord ainda estiver em execução, você pode parar seu processo com CTRL + C.

      Abra seu arquivo index.js novamente:

      Para começar a implementar o comando "! sum", você usará um bloco else-if. Depois de verificar o nome do comando ping, ele irá verificar se o nome do comando é igual a "sum". Usamos um bloco else-if já que apenas um comando irá processar de cada vez, então se o programa corresponder ao nome de comando "ping", ele não precisa verificar o comando "sum". Adicione as seguintes linhas destacadas ao seu arquivo:

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Ping! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
                                     
        }                            
      });
      ...
      

      Você pode começar a implementar o código para o comando "sum". O código para o comando "sum" irá entrar dentro do bloco else-if que você acabou de criar. Agora, adicione o código a seguir:

      index.js

      ...
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      ...
      

      Você usa o método map na lista argumentos para criar uma nova lista usando a função parseFloat em cada item no array args. Isso cria um novo array (atribuído à constante numArgs) no qual todos os itens são números em vez de strings. Isso significa que mais tarde você pode encontrar com sucesso a soma dos números adicionando-os.

      A segunda linha usa o método reduce na constante numArgs, fornecendo uma função que totaliza todos os elementos na lista. Você atribui a soma de todos os elementos em numArgs à constante. sum.

      Em seguida, você usa o método reply no objeto message para responder ao comando do usuário com modelo literal, que contém a soma de todos os argumentos que o usuário envia para o bot.

      Isso conclui a implementação do comando "sum". Agora, execute o bot usando o comando a seguir (na mesma pasta que index.js):

      Agora, você pode usar o comando "! sum"” em qualquer canal em que o bot possa visualizar e enviar mensagem.

      Image of bot replying

      A seguir está uma versão finalizada do script index.js do bot:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      
      const client = new Discord.Client();
      
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      });
      
      client.login(config.BOT_TOKEN);
      

      Neste passo, você melhorou ainda mais seu bot Discord implementando o comando sum.

      Conclusão

      Você implementou com sucesso um bot Discord que pode lidar com vários comandos de usuário e argumentos de comando diferentes. Se você quiser expandir seu bot, você pode possivelmente implementar mais comandos ou experimentar mais partes da API do Discord para criar um bot Discord poderoso. Você pode revisar a documentação do Discord.js ou a documentação da API do Discord para expandir seu conhecimento da API Discord.

      Ao criar bots no Discord, você deve sempre ter em mente os termos de serviço da API do Discord, que descreve como os desenvolvedores devem utilizar a API. Você também pode ler este conjunto de diretrizes sobre como implementar melhor um bot Discord, e fornece dicas sobre como projetar bots no Discord. Se você quiser aprender mais sobre o Node.js confira nossa série How To Code in Node.js.



      Source link

      Создание бота Discord Bot с помощью Node.js


      Автор выбрал фонд Free and Open Source Fund для получения пожертвования в рамках программы Write for DOnations.

      Введение

      Discord — это приложение чата, позволяющее миллионам пользователей со всего мира обмениваться сообщениями и общаться в голосовом чате в сообществах, называемых «гильдии» или «серверы». Discord также включает функциональный API, который разработчики смогут использовать для построения мощных ботов Discord. Боты могут выполнять разнообразные действия, в том числе отправлять сообщения на серверы, отправлять пользователям сообщения DM, модерировать серверы и воспроизводить звук в голосовых чатах. Это позволяет разработчикам создавать мощных ботов со сложными и продвинутыми функциями, включая инструменты модерирования и даже игры. Например, служебный бот Dyno обслуживает миллионы гильдий и содержит множество полезных функций, включая защиту от спама, музыкальный проигрыватель и другие служебные функции. Научившись создавать боты Discord, вы получите множество возможностей, с которыми тысячи людей смогут взаимодействовать каждый день.

      В этом обучающем модуле мы создадим бот Discord с нуля, используя Node.js и библиотеку Discord.js, позволяющую пользователям взаимодействовать с Discord API напрямую. Мы настроим профиль бота Discord, получим токены аутентификации для бота и запрограммируем бот для обработки отправляемых пользователями команд с аргументами.

      Предварительные требования

      Для начала вам потребуется следующее:

      Шаг 1 — Настройка бота Discord

      На этом шаге вы будете использовать графический интерфейс разработчиков Discord для настройки бота Discord и получения токена бота, который вы передадите в свою программу.

      Чтобы зарегистрировать бота на платформе Discord, используйте панель приложений Discord. Здесь разработчики могут создавать приложения Discord, включая ботов Discord.

      Изображение панели приложений Discord после первого посещения сайта https://discord.com/developers/applications

      Для начала нажмите New Application (Новое приложение). Discord предложит вам ввести имя нового приложения. Затем нажмите Create (Создать) для создания приложения.

      Изображение командной строки для создания приложения с введенным именем приложения

      Примечание. Имя приложения не связано с именем бота, и эти имена могут не совпадать.

      Теперь откройте свою панель приложения. Чтобы добавить бота в приложение, откройте вкладку Bot (Бот) на панели навигации слева.

      Изображение вкладки Bot на панели приложений

      Нажмите кнопку Add Bot (Добавить бота), чтобы добавить бота в приложение. Нажмите кнопку Yes, do it! (Да, сделать это!) в диалоге запроса подтверждения. Откроется панель с подробными сведениями об имени вашего бота, токене аутентификации и изображении в профиле.

      Панель с подробными сведениями о боте

      На этой панели вы можете изменить имя бота или изображение профиля. Также необходимо скопировать токен аутентификации бота, нажав Click to Reveal Token (Нажмите для показа токена) и скопировав отображаемый токен.

      Предупреждение. Никогда не публикуйте и не выгружайте в сеть свой токен бота, поскольку это позволит любому пользователю выполнить вход в бот.

      Теперь нужно создать приглашение, которое позволяет добавить гильдии ботов Discord, где вы можете протестировать бот. Вначале перейдите на вкладку OAuth2 на панели приложения. Чтобы создать приглашения, прокрутите страницу и выберите бота в разделе scopes. Также необходимо установить разрешения, чтобы определить, какие действия бот может выполнять в гильдиях. Для целей этого обучающего модуля выберите пункт Administrator (Администратор), которые дадут вашему боту разрешения для выполнения в гильдиях практически любых действий. Скопируйте ссылку с помощью кнопки Copy.

      Вкладка OAuth2 с установленной сферой действия bot и уровнем разрешений administator

      Затем добавьте бот на сервер. Перейдите по созданной ссылке с приглашением. Вы можете добавить бот на любой сервер, который вам принадлежит или на котором у вас есть права администратора, используя выпадающее меню.

      Страница после перехода по ссылке с приглашением, что позволяет пользователям добавлять бот на серверы

      Теперь нажмите кнопку Continue (Продолжить). Обязательно установите отметку рядом с полем Administrator, чтобы предоставить боту разрешения администратора. Затем нажмите Authorize (Авторизация). Discord предложит вам решить головоломку CAPTCHA, прежде чем бот сможет подключиться к серверу. Теперь наш бот Discord отображается в списке пользователей сервера, на который вы добавили бота, со статусом offline (не в сети).

      Список пользователей сервера Discord с новым ботом в разделе offline списка пользователей

      Вы успешно создали бота Discord и добавили его на сервер. Далее мы напишем программу для входа в бот.

      Шаг 2 — Создание проекта

      На этом шаге мы настроим базовую среду программирования, где выполним сборку бота и войдем в него программным путем.

      Вначале необходимо настроить папку проекта и необходимые файлы проекта для бота.

      Создайте папку проекта:

      Перейдите в только что созданную папку проекта:

      Далее используйте текстовый редактор для создания файла с именем config.json для сохранения токена аутентификации вашего бота:

      Затем добавьте в файл конфигурации следующий код, заменяя выделенный текст токеном аутентификации вашего бота:

      config.json

      {
          "BOT_TOKEN": "YOUR BOT TOKEN"
      }
      

      Сохраните и закройте файл.

      Затем мы создадим файл package.json, где будут храниться детали нашего проекта и информация о зависимостях, используемых в проекте. Для создания файла package.json запустите следующую команду npm:

      npm запросит различные детали вашего проекта. Если вам нужны указания по ответам на эти запросы, воспользуйтесь руководством «Использование модулей Node.js с npm и package.json».

      Сейчас мы установим пакет discord.js, который будем использовать для взаимодействия с Discord API. Вы можете установить discord.js через npm с помощью следующей команды:

      Мы настроили файл конфигурации, установили необходимую зависимость и теперь можем начать сборку бота. В реальном приложении мы бы разделили код большого бота на несколько файлов, но в этом обучающем модуле мы поместим весь код бота в один файл.

      Вначале создайте файл с именем index.js в папке discord-bot для кода:

      Начните программирование бота, запросив зависимость discord.js и файл конфигурации с токеном бота:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      

      После этого добавьте следующие две строки кода:

      index.js

      ...
      const client = new Discord.Client();
      
      client.login(config.BOT_TOKEN);
      

      Сохраните и закройте файл.

      Первая строка кода создает новый клиент Discord.Client и назначает его как значение константы client. Этот клиент частично обеспечивает взаимодействие с Discord API и получает уведомления Discord о событиях, например, о новых сообщениях. Фактически клиент представляет бот Discord.

      Во второй строке кода метод login используется на клиенте для входа в созданный бот Discord с использованием токена в файле config.json в качестве пароля. Токен сообщает Discord API, для какого бота предназначена программа, а также подтверждает вашу аутентификацию для использования бота.

      Теперь запустите файл index.js с помощью Node:

      Теперь статус вашего бота на сервере Discord, куда вы его добавили, изменится на online (в сети).

      Изображение бота со статусом online

      Мы успешно настроили среду программирования и создали базовый код для входа в бот Discord. На следующем шаге мы займемся пользовательскими командами и заставим бота выполнить определенные действия, например, отправить сообщения.

      Шаг 3 — Обработка первой команды пользователя

      На этом шаге мы создадим бот, который может обрабатывать команды пользователя. Вы запустите свою первую команду ping, на которую будет отправлен ответ pong с указанием времени ответа на команду.

      Сначала необходимо обеспечить обнаружение и получение любых отправляемых пользователями сообщений, чтобы бот мог обрабатывать любые команды. Используя метод on клиента Discord, Discord будет отправлять вам уведомления о новых событиях. Метод on принимает два аргумента: название ожидаемого события и функцию, которая будет запускаться каждый раз, когда будет возникать это событие. С этим методом вы можете ожидать события message, которое будет возникать каждый раз при отправке сообщения в гильдию, где у бота имеется разрешение на просмотр сообщений. Поэтому мы создадим функцию, которая будет запускаться для обработки команд каждый раз при отправке сообщения.

      Вначале откройте свой файл:

      Добавьте в файл следующий код:

      index.js

      ...
      const client = new Discord.Client();
      
      
      client.on("message", function(message) { 
                                               
      });                                      
      
      client.login(config.BOT_TOKEN);
      

      Эта функция, выполняемая для события message, принимает параметр message. Параметр message имеет значение экземпляра Discord.js message, содержащее информацию об отправленном сообщении и методах, которые помогут боту ответить на него.

      Добавьте следующую строку кода в функцию обработки команд:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
      });
      ...
      

      Эта строка проверяет, является ли автор сообщения ботом, и если это так, останавливает обработку команды. Это важно, поскольку обычно нам не нужно обрабатывать сообщения ботов или отвечать на них. Другим ботам обычно не требуется использовать наш бот, и поэтому игнорирование их сообщений позволит нам сэкономить вычислительную мощность и предотвратить случайные ответы.

      Теперь мы напишем обработчик команд. Для этого важно понимать обычный формат команды Discord. Обычно структура команды Discord содержит три части в следующем порядке: префикс, имя команды и (иногда) аргументы команды.

      Изображение типичной команды Discord

      • Префикс: префикс может быть любым, но обычно это знак пунктуации или абстрактная фраза, которая обычно не может располагаться в начале сообщения. Это означает, что при добавлении префикса в начало сообщения бот будет знать, что это команда, которую ему необходимо обработать.

      • Имя команды: имя команды, которое пользователь хочет использовать. Это означает, что бот может поддерживать несколько команд с разными функциями и разрешать пользователям выбирать между ними, используя разные имена команд.

      • Аргументы: иногда команда запрашивает или использует дополнительную информацию от пользователя, и пользователь может указывать аргументы после имени команды, разделяя их пробелами.

      Примечание. Принудительно устанавливаемой структуры команд нет, и боты могут обрабатывать команды как угодно, однако здесь мы описываем эффективную структуру, которую использует большинство ботов.

      Чтобы начать создание синтаксического анализатора команд, поддерживающего этот формат, добавьте следующие строки кода в функцию обработки сообщений:

      index.js

      ...
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      });
      ...
      

      Первая строка кода добавляется, чтобы присвоить значение "!" константе prefix, которую мы будем использовать в качестве префикса бота.

      Вторая строка кода проверяет, начинается ли содержание обрабатываемого ботом сообщения с заданного префикса, и останавливает дальнейшую обработку сообщения, если префикса нет.

      Теперь необходимо конвертировать остальную часть сообщения в название команды и любые аргументы, которые могут присутствовать в сообщении. Добавьте следующие выделенные строки:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      });
      ...
      

      Первая строка используется для удаления префикса из содержания сообщения и назначения результата константе commandBody. Это необходимо, поскольку нам не нужно, чтобы префикс входил в обработанное имя команды.

      Вторая строка принимает сообщение с удаленным префиксом и использует на нем метод split с пробелом в качестве разделителя. Он разделяет команду на массив субстрок, проводя разделение после каждого пробела. В результате получается массив, содержащий имя команды, за которым идут аргументы (если они содержатся в сообщении). Мы назначаем этот массив константе args.

      Третья строка удаляет первый элемент из массива args (это будет имя команды), конвертирует его в нижний регистр и назначает константе command. Это позволяет изолировать имя команды и оставить в массиве только аргументы. Также мы используем метод toLowerCase, поскольку команды в ботах Discord обычно не учитывают регистр.

      Мы завершили построение синтаксического анализатора команд с реализацией обязательного префикса и получением имени команды и всех аргументов из сообщений. Теперь мы реализуем и создадим код для определенных команд.

      Добавьте следующий код, чтобы начать реализацию команды ping:

      index.js

      ...
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
                                 
        }                        
      });
      ...
      

      Это выражение if проверяет соответствие обработанного имени команды (назначенного константе command) значению "ping". Такое соответствие означает, что пользователь хочет использовать команду "ping". Мы вложим код определенной команды в блок выражения if. Впоследствии вы сможете использовать этот шаблон для других команд.

      Теперь вы можете реализовать код для команды "ping":

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      ...
      

      Сохраните и закройте файл.

      Мы добавляем блок команды "ping", который рассчитывает разницу между текущим временем, определяемым с помощью метода now объекта Date, и временной меткой создания сообщения, выражаемую в миллисекундах. Таким образом рассчитывается время обработки сообщения и ответа бота на команду "ping".

      Вторая строка отвечает на команду пользователя, используя метод reply с константой message. Метод reply отправляет запрос ping (уведомляющий пользователя и выделяющий сообщение для указанного пользователя) пользователю, который отправил команду, добавляя после запроса содержание, указанное в качестве первого аргумента метода. Мы указали литераль шаблона, содержащую сообщение и рассчитанное значение ping, в качестве ответа, который будет использоваться методом reply.

      На этом мы завершаем реализацию команды "ping".

      Запустите свой бот с помощью следующей команды (в той же папке, что и index.js):

      Теперь вы можете использовать команду "! ping" на любом канале, где бот может просматривать и принимать сообщения, а также отправлять ответы.

      Изображение бота, отвечающего в Discord на запрос

      Вы успешно создали бот, который может обрабатывать команды пользователей, и реализовали свою первую команду. На следующем шаге мы продолжим разработку бота, реализовав команду sum.

      Шаг 4 — Реализация команды Sum

      Теперь мы расширим нашу программу, реализовав команду "! sum". Эта команда принимает любое количество аргументов, складывает их и возвращает пользователю сумму всех аргументов.

      Если ваш бот Discord еще работает, вы можете остановить его процессы, нажав CTRL + C.

      Откройте файл index.js снова:

      Чтобы начать реализацию команды "! sum", мы используем блок else-if. После проверки имени команды ping бот будет проверять, имеет ли имя команды значение "sum". Мы используем блок else-if, потому что одновременно будет обрабатываться только одна команда, и если программа определит совпадение с именем команды "ping", ей не нужно будет проводить проверку на совпадение с именем команды "sum". Добавьте в файл следующие выделенные строки:

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Ping! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
                                     
        }                            
      });
      ...
      

      Теперь вы можете начать реализацию кода для команды "sum". Код команды "sum" будет размещен в только что созданном нами блоке else-if. Теперь добавьте следующий код:

      index.js

      ...
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      ...
      

      Мы используем метод map для списка аргументов, чтобы создать новый список, используя функцию parseFloat для каждого элемента в массиве args. При этом создается новый массив (назначенный константе numArgs), где все элементы являются числами, а не строками. Это означает, что в дальнейшем вы можете определить сумму чисел, выполнив операцию сложения.

      Вторая строка использует метод reduce на константе numArgs, предоставляя функцию, суммирующую все элементы в списке. Мы назначаем сумму всех элементов в numArgs как значение константы sum.

      Затем мы используем метод reply на объекте сообщений, чтобы ответить на команду пользователя, отправив литераль шаблона, содержащую сумму всех аргументов, отправленных пользователем боту.

      Это завершает реализацию команды "sum". Теперь запустите бот, используя следующую команду (в той же папке, что и index.js):

      Теперь вы можете использовать команду "! sum" на любом канале, где бот может просматривать и отправлять сообщения.

      Изображение бота, отвечающего

      Далее приведена законченная версия скрипта бота index.js:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      
      const client = new Discord.Client();
      
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      });
      
      client.login(config.BOT_TOKEN);
      

      На этом шаге мы дополнили наш бот Discord, реализовав в нем команду sum.

      Заключение

      Мы успешно создали бот Discord, который может обрабатывать разные команды пользователей и аргументы команд. Если вы хотите расширить возможности вашего бота, вы можете реализовать дополнительные команды или использовать другие части Discord API для построения мощного бота Discord. Вы можете ознакомиться с документацией по Discord.js или Discord API, чтобы узнать больше о Discord API.

      При создании ботов Discord всегда помните об условиях обслуживания Discord API, определяющих требования к использованию Discord API разработчиками. Также вам может быть полезен этот набор рекомендаций, показывающий наилучшие способы построения бота Discord и содержащий советы по проектированию ботов Discord. Если вы хотите узнать больше о Node.js, ознакомьтесь с нашей серией материалов «Программирование в Node.js».



      Source link

      Zentralisieren von Protokollen mit Journald unter Ubuntu 20.04


      Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Systemprotokolle sind ein äußerst wichtiger Bestandteil für die Verwaltung von Linux-Systemen. Sie bieten einen unschätzbaren Einblick in die Funktionsweise und Verwendung der Systeme, da sie neben Fehlern auch Betriebsinformationen wie Sicherheitsereignisse aufzeichnen. Die Standardkonfiguration für Linux-Systeme besteht darin, ihre Protokolle lokal auf demselben System zu speichern, auf dem sie aufgetreten sind. Dies funktioniert für eigenständige Systeme, wird jedoch mit zunehmender Anzahl von Systemen schnell zu einem Problem. Die Lösung für die Verwaltung all dieser Protokolle besteht darin, einen zentralen Protokollierungsserver zu erstellen, auf dem jeder Linux-Host seine Protokolle in Echtzeit an einen dedizierten Protokollverwaltungsserver sendet.

      Eine zentralisierte Protokollierungslösung bietet im Vergleich zum Speichern von Protokollen auf jedem Host mehrere Vorteile:

      • Reduziert den Speicherplatz, der auf jedem Host zum Speichern von Protokolldateien benötigt wird.
      • Protokolle können länger aufbewahrt werden, da der dedizierte Protokollserver mit mehr Speicherkapazität konfiguriert werden kann.
      • Es kann eine erweiterte Protokollanalyse durchgeführt werden, die Protokolle von mehreren Systemen und mehr Rechenressourcen erfordert, als auf den Hosts verfügbar sind.
      • Systemadministratoren können auf die Protokolle aller ihrer Systeme zugreifen, bei denen sie sich aus Sicherheitsgründen möglicherweise nicht direkt anmelden können.

      In diesem Leitfaden konfigurieren Sie eine Komponente der Tool-Suite systemd, um Protokollnachrichten von Client-Systemen an einen zentralen Protokollsammlungsserver weiterzuleiten. Sie konfigurieren den Server und den Client so, dass TLS-Zertifikate verwendet werden, um die Protokollnachrichten zu verschlüsseln, wenn sie über unsichere Netzwerke wie das Internet übertragen werden, und um sich gegenseitig zu authentifizieren.

      Voraussetzungen

      Bevor Sie diese Anleitung beginnen, benötigen Sie Folgendes:

      • Zwei Ubuntu 20.04-Server.
      • Einen Nicht-root-Benutzer mit Sudo-Berechtigungen auf beiden Servern. Anweisungen dazu finden Sie im Leitfaden zur Ersteinrichtung des Servers mit Ubuntu 20.04. Sie sollten auch die UFW-Firewall auf beiden Servern konfigurieren, wie im Leitfaden erläutert.
      • Zwei Hostnamen, die auf Ihre Server verweisen. Ein Hostname für das Client-System, das die Protokolle generiert, und ein anderer für den Protokollsammlungsserver. In der Domains- und DNS-Dokumentation erfahren Sie, wie Sie Hostnamen auf DigitalOcean Droplets verweisen.

      In diesem Leitfaden werden die folgenden zwei Beispiel-Hostnamen verwendet:

      • client.your_domain: Das Client-System, das die Protokolle generiert.
      • server.your_domain: Der Protokollsammlungsserver.

      Melden Sie sich sowohl beim Client als auch beim Server in separaten Terminals über SSH als Nicht-root-sudo-Benutzer an, um dieses Tutorial zu starten.

      Hinweis: Während des gesamten Tutorials werden Befehlsblöcke mit dem Namen des Servers (Client oder Server) gekennzeichnet, auf dem der Befehl ausgeführt werden soll.

      Schritt 1 — Installieren von systemd-journal-remote

      In diesem Schritt installieren Sie das Paket systemd-journal-remote auf dem Client und dem Server. Dieses Paket enthält die Komponenten, die der Client und der Server zum Weiterleiten von Protokollnachrichten verwenden.

      Führen Sie zunächst sowohl auf dem Client als auch auf dem Server ein Systemupdate aus, um sicherzustellen, dass die Paketdatenbank und das System aktuell sind:

      Client and Server

      • sudo apt update
      • sudo apt upgrade

      Installieren Sie das Paket systemd-journal-remote:

      Client and Server

      • sudo apt install systemd-journal-remote

      Aktivieren und starten Sie auf dem Server die beiden systemd-Komponenten, die zum Empfangen von Protokollnachrichten benötigt werden, mit dem folgenden Befehl:

      Server

      • sudo systemctl enable --now systemd-journal-remote.socket
      • sudo systemctl enable systemd-journal-remote.service

      Die Option --now im ersten Befehl startet die Dienste sofort. Sie haben es im zweiten Befehl nicht verwendet, da dieser Dienst erst gestartet wird, wenn er über TLS-Zertifikate verfügt, die Sie im nächsten Schritt erstellen.

      Aktivieren Sie auf dem Client die Komponente, mit der systemd die Protokollnachrichten an den Server sendet:

      Client

      • sudo systemctl enable systemd-journal-upload.service

      Öffnen Sie anschließend auf dem Server die Ports 19532 und 80 in der UFW-Firewall. Dadurch kann der Server die Protokollnachrichten vom Client empfangen. Port 80 ist der Port, über den Certbot das TLS-Zertifikat generiert. Die folgenden Befehle öffnen diese Ports:

      Server

      • sudo ufw allow in 19532/tcp
      • sudo ufw allow in 80/tcp

      Auf dem Client müssen Sie Port 80 nur mit diesem Befehl öffnen:

      Client

      Sie haben jetzt die erforderlichen Komponenten installiert und die Basissystemkonfiguration auf dem Client und dem Server abgeschlossen. Bevor Sie diese Komponenten so konfigurieren können, dass sie mit der Weiterleitung von Protokollnachrichten beginnen, registrieren Sie die Let’s Encrypt TLS-Zertifikate für den Client und den Server mithilfe des Dienstprogramms certbot.

      Schritt 2 – Installieren von Certbot und Registrieren von Zertifikaten

      Let’s Encrypt ist eine Zertifizierungsstelle, die kostenlose TLS-Zertifikate ausstellt. Mit diesen Zertifikaten können Computer sowohl die zwischen ihnen gesendeten Daten verschlüsseln als auch die Identität des anderen überprüfen. Mit diesen Zertifikaten können Sie Ihr Surfen im Internet mit HTTPS sichern. Dieselben Zertifikate können von jeder anderen Anwendung verwendet werden, die dieselbe Sicherheitsstufe wünscht. Der Prozess der Registrierung des Zertifikats ist der gleiche, unabhängig davon, wofür Sie es verwenden.

      In diesem Schritt installieren Sie das Dienstprogramm certbot und registrieren damit die Zertifikate. Außerdem wird es automatisch darum kümmern, die Zertifikate zu erneuern, wenn sie ablaufen. Der Registrierungsvorgang ist hier der gleiche auf dem Client und dem Server. Sie müssen nur den Hostnamen ändern, um ihn an den Host anzupassen, auf dem Sie den Registrierungsbefehl ausführen.

      Aktivieren Sie zunächst das universe-Repository von Ubuntu, da sich das Dienstprogramm certbot im universe-Repository befindet. Wenn Sie das universe-Repository bereits aktiviert haben, wird eine Ausführung dieser Befehle in Ihrem System nichts verändern und ist somit sicher:

      Client and Server

      • sudo apt install software-properties-common
      • sudo add-apt-repository universe
      • sudo apt update

      Als Nächstes installieren Sie certbot auf beiden Hosts:

      Client and Server

      Nachdem Sie certbot installiert haben, führen Sie den folgenden Befehl aus, um die Zertifikate auf dem Client und Server zu registrieren:

      Client and Server

      • sudo certbot certonly --standalone --agree-tos --email sammy@your_domain -d your_domain

      Die Optionen in diesem Befehl bedeuten Folgendes:

      • certonly: Registrieren Sie das Zertifikat und führen Sie keine anderen Änderungen am System vor.
      • --standalone: Verwenden Sie den integrierten Webserver von certbot zur Verifizierung der Zertifikatsanforderung.
      • -agree-tos: Stimmen Sie automatisch den Nutzungsbedingungen von Let’s Encrypt zu.
      • --email your_email: Dies ist die E-Mail-Adresse, mit der Let’s Encrypt Sie über den Ablauf des Zertifikats und andere wichtige Informationen benachrichtigt.
      • -d your_domain: Der Hostname, für den das Zertifikat registriert wird. Dies muss dem System entsprechen, in dem Sie es ausführen.

      Wenn Sie diesen Befehl ausführen, werden Sie gefragt, ob Sie die E-Mail-Adresse mit Let’s Encrypt teilen möchten, damit diese Ihnen Nachrichten und andere Informationen zu ihrer Arbeit per E-Mail senden können. Dies ist optional. Wenn Sie Ihre E-Mail-Adresse nicht teilen, wird die Zertifikatsregistrierung weiterhin normal abgeschlossen.

      Wenn der Zertifikatregistrierungsprozess abgeschlossen ist, werden die Zertifikat- und Schlüsseldateien in /etc/letsencrypt/live/your_domain/ abgelegt, wobei your_domain der Hostname ist, für den Sie das Zertifikat registriert haben.

      Schließlich müssen Sie eine Kopie der Let’s Encrypt-Zertifizierungsstelle und der Zwischenzertifikate herunterladen und in dieselbe Datei einfügen. journald verwendet diese Datei, um die Authentizität der Zertifikate auf dem Client und dem Server zu überprüfen, wenn diese miteinander kommunizieren.

      Mit dem folgenden Befehl werden die beiden Zertifikate von der Let’s Encrypt-Website heruntergeladen und in einer einzigen Datei mit dem Namen letsencrypt-combined-certs.pem im Home-Verzeichnis Ihres Benutzers abgelegt.

      Führen Sie diesen Befehl auf dem Client und dem Server aus, um die Zertifikate herunterzuladen und die kombinierte Datei zu erstellen:

      Client and Server

      • curl -s https://letsencrypt.org/certs/{isrgrootx1.pem.txt,letsencryptauthorityx3.pem.txt} > ~/letsencrypt-combined-certs.pem

      Verschieben Sie als Nächstes diese Datei in das Verzeichnis Let’s Encrypt, das die Zertifikate und Schlüssel enthält:

      Client and Server

      • sudo cp ~/letsencrypt-combined-certs.pem /etc/letsencrypt/live/your_domain/

      Sie haben nun die Zertifikate und Schlüssel registriert. Im nächsten Schritt konfigurieren Sie den Protokollsammlungsserver so, dass er Protokollnachrichten vom Client abhört und speichert.

      Schritt 3 – Konfigurieren des Servers

      In diesem Schritt konfigurieren Sie den Server so, dass er die im letzten Schritt generierten Zertifikat- und Schlüsseldateien verwendet, damit er Protokollnachrichten vom Client akzeptieren kann.

      systemd-journal-remote ist die Komponente, die auf Protokollnachrichten wartet. Öffnen Sie ihre Konfigurationsdatei unter /etc/systemd/journal-remote.conf mit einem Texteditor, um die Konfiguration auf dem Server zu starten:

      • sudo nano /etc/systemd/journal-remote.conf

      Entfernen Sie anschließend die Kommentare in allen Zeilen im Abschnitt [Remote] und legen Sie die Pfade so fest, dass sie auf die soeben erstellten TLS-Dateien verweisen:

      /etc/systemd/journal-remote.conf

      [Remote]
      Seal=false
      SplitMode=host
      ServerKeyFile=/etc/letsencrypt/live/server.your_domain/privkey.pem
      ServerCertificateFile=/etc/letsencrypt/live/server.your_domain/fullchain.pem
      TrustedCertificateFile=/etc/letsencrypt/live/server.your_domain/letsencrypt-combined-certs.pem
      

      Hier sind die Optionen, die Sie hier verwendet haben:

      • Seal=false: Melden Sie die Protokolldaten im Journal an. Aktivieren Sie diese Option, wenn Sie maximale Sicherheit benötigen; andernfalls können Sie es als false belassen.
      • SplitMode=host: Die Protokolle der Remoteclients werden nach Host in /var/log/journal/remote geteilt. Wenn Sie möchten, dass alle Protokolle einer einzelnen Datei hinzugefügt werden, setzen Sie dies auf SplitMode=false.
      • ServerKeyFile: Die private Schlüsseldatei des Servers.
      • ServerCertificateFile: Die Zertifikatdatei des Servers.
      • TrustedCertificateFile: Die Datei mit den Let’s Encrypt CA-Zertifikaten.

      Jetzt müssen Sie die Berechtigungen für die Let’s Encrypt-Verzeichnisse ändern, die die Zertifikate und den Schlüssel enthalten, damit die systemd-journal-remote sie lesen und verwenden kann.

      Ändern Sie zunächst die Berechtigungen so, dass das Zertifikat und der private Schlüssel lesbar sind:

      • sudo chmod 0755 /etc/letsencrypt/{live,archive}
      • sudo chmod 0640 /etc/letsencrypt/live/server.your_domain/privkey.pem

      Ändern Sie als Nächstes das Gruppeneigentum des privaten Schlüssels in die Gruppe von systemd-journal-remote:

      • sudo chgrp systemd-journal-remote /etc/letsencrypt/live/server.your_domain/privkey.pem

      Jetzt können Sie systemd-journal-remote starten:

      • sudo systemctl start systemd-journal-remote.service

      Ihr Protokollsammlungs server wird jetzt ausgeführt und ist bereit, Protokollnachrichten von einem Client zu akzeptieren. Im nächsten Schritt konfigurieren Sie den Client so, dass die Protokolle an Ihren Sammlungs server weitergeleitet werden.

      Schritt 4 – Konfigurieren des Clients

      In diesem Schritt konfigurieren Sie die Komponente, die die Protokollnachrichten an den Protokollsammlungsserver weiterleitet. Diese Komponente wird systemd-journal-upload genannt.

      Die Standardkonfiguration für systemd-journal-upload ist, dass ein temporärer Benutzer verwendet wird, der nur vorhanden ist, während der Prozess ausgeführt wird. Dies erschwert das Lesen der TLS-Zertifikate und -Schlüssel durch systemd-journal-upload. Um dies zu beheben, erstellen Sie einen neuen Systembenutzer mit demselben Namen wie der temporäre Benutzer, der an seiner Stelle verwendet wird.

      Erstellen Sie zunächst den neuen Benutzer mit dem Namen systemd-journal-upload auf dem Client mit dem folgenden adduser-Befehl:

      • sudo adduser --system --home /run/systemd --no-create-home --disabled-login --group systemd-journal-upload

      Diese Optionen für den Befehl lauten:

      • --system: Erstellen Sie den neuen Benutzer als Systembenutzer. Dadurch wird dem Benutzer eine UID-Nummer (Benutzerkennung) unter 1000 gegeben. UIDs über 1000 werden normalerweise an Benutzerkonten vergeben, mit denen sich ein Mensch anmeldet.
      • --home/run/systemd: Legen Sie /run/systemd als Home-Verzeichnis für diesen Benutzer fest.
      • --no-create-home: Erstellen Sie das Home-Verzeichnis nicht, da es bereits vorhanden ist.
      • --disabled-login: Der Benutzer kann sich beispielsweise nicht über SSH beim Server anmelden.
      • --group: Erstellen Sie eine Gruppe mit demselben Namen wie der Benutzer.

      Legen Sie als Nächstes die Berechtigungen und den Besitz der Let’s Encrypt-Zertifikatdateien fest:

      • sudo chmod 0755 /etc/letsencrypt/{live,archive}
      • sudo chmod 0640 /etc/letsencrypt/live/client.your_domain/privkey.pem
      • sudo chgrp systemd-journal-upload /etc/letsencrypt/live/client.your_domain/privkey.pem

      Bearbeiten Sie nun die Konfiguration für systemd-journal-upload unter /etc/systemd/journal-upload.conf. Öffnen Sie diese Datei mit einem Texteditor:

      • sudo nano /etc/systemd/journal-upload.conf

      Bearbeiten Sie diese Datei, damit sie wie folgt aussieht:

      /etc/systemd/journal-upload.conf

      [Upload]
      URL=https://server.your_domain:19532
      ServerKeyFile=/etc/letsencrypt/live/client.your_domain/privkey.pem
      ServerCertificateFile=/etc/letsencrypt/live/client.your_domain/fullchain.pem
      TrustedCertificateFile=/etc/letsencrypt/live/client.your_domain/letsencrypt-combined-certs.pem
      

      Starten Sie abschließend den systemd-journal-upload-Dienst neu, damit er die neue Konfiguration verwendet:

      • sudo systemctl restart systemd-journal-upload.service

      Ihr Client ist jetzt eingerichtet und wird ausgeführt und sendet seine Protokollnachrichten an den Protokollsammlungsserver. Im nächsten Schritt überprüfen Sie, ob die Protokolle korrekt gesendet und aufgezeichnet werden.

      Schritt 5 – Testen des Clients und des Servers

      In diesem Schritt testen Sie, ob der Client Protokollnachrichten an den Server weiterleitet und ob der Server sie korrekt speichert.

      Der Protokollsammlungsserver speichert die Protokolle von den Clients in einem Verzeichnis unter /var/log/journal/remote/. Wenn Sie den Client am Ende des letzten Schritts neu gestartet haben, wurden Protokollnachrichten gesendet, sodass sich jetzt eine Protokolldatei in /var/log/journal/remote/ befindet. Die Datei wird nach dem Hostnamen, den Sie für das TLS-Zertifikat verwenden, benannt.

      Verwenden Sie den Befehl Is, um zu überprüfen, ob die Protokolldatei des Clients auf dem Server vorhanden ist:

      Server

      • sudo ls -la /var/log/journal/remote/

      Dadurch wird der Verzeichnisinhalt mit der Protokolldatei gedruckt:

      Output

      total 16620 drwxr-xr-x 2 systemd-journal-remote systemd-journal-remote 4096 Jun 30 16:17 . drwxr-sr-x+ 4 root systemd-journal 4096 Jun 30 15:55 .. -rw-r----- 1 systemd-journal-remote systemd-journal-remote 8388608 Jul 1 10:46 'remote-CN=client.your_domain'

      Schreiben Sie als Nächstes eine Protokollnachricht auf den Client, um zu überprüfen, ob der Server die Nachrichten des Clients wie erwartet empfängt. Mit dem Dienstprogramm logger erstellen Sie eine benutzerdefinierte Protokollnachricht auf dem Client. Wenn alles funktioniert, leitet systemd-journal-upload diese Nachricht an den Server weiter.

      Führen Sie auf dem Client den folgenden logger-Befehl aus:

      Client

      • sudo logger -p syslog.debug "### TEST MESSAGE from client.your_domain ###"

      -p syslog.debug in diesem Befehl legt Funktion und Schweregrad der Nachricht fest. Wenn man dies auf syslog.debug setzt, wird deutlich, dass es sich um eine Testnachricht handelt. Dieser Befehl zeichnet die Nachricht ### TEST MESSAGE from client.your_domain ### im Journal des Clients auf, das dann vom systemd-journal-upload an den** Server** weitergeleitet wird.

      Lesen Sie als Nächstes die Journaldatei des Clients auf dem Server, um zu überprüfen, ob die Protokollnachrichten vom Client eingehen. Diese Datei ist eine binäre Protokolldatei, sodass Sie sie mit Tools wie less nicht lesen können. Lesen Sie die Datei stattdessen mit journalctl mit der Option --file =, mit der Sie eine benutzerdefinierte Journaldatei angeben können:

      Server

      • sudo journalctl --file=/var/log/journal/remote/remote-CN=client.your_domain.journal

      Die Protokollnachricht wird wie folgt angezeigt:

      Test log message

      . . . Jun 29 13:10:09 client root[3576]: ### TEST MESSAGE from client.your_domain ###

      Ihr Protokollzentralisierungsserver sammelt jetzt erfolgreich Protokolle von Ihrem Client-System.

      Zusammenfassung

      In diesem Artikel haben Sie einen zentralen Protokollsammlungsserver eingerichtet und einen Client so konfiguriert, dass eine Kopie seiner Systemprotokolle an den Server weitergeleitet wird. Mit den hier verwendeten Client-Konfigurationsschritten können Sie so viele Clients konfigurieren, wie Sie zum Weiterleiten von Nachrichten an den Protokollsammlungsserver benötigen.



      Source link