Participe da Maratona Behind the Code! A competição de programação que mais te desafia! Inscreva-se aqui

Arquivado | Integrando o Watson no Minecraft

Conteúdo arquivado

Data de arquivamento: 2019-11-25

Esse conteúdo não está mais sendo atualizado ou passando por manutenção. Esse conteúdo está sendo providenciado “da forma que está”. Considerando a rápida evolução da tecnologia, alguns conteúdos, passos, ou ilustrações podem ter mudado.

Na Parte 1, Parte 2 e A Parte 3, você viu como iniciar seu próprio servidor do Minecraft dentro de um container do Docker, primeiro localmente e, depois, dentro do IBM Container Service no IBM Cloud. Também aprendeu sobre o desenvolvimento de plug-ins no lado do servidor para Minecraft e incluir tais plug-ins no servidor do Minecraft em execução no Docker.

Tudo isso foi um prelúdio para este tutorial (o último da série), que mostra como usar o poder do ambiente do IBM Cloud no seu desenvolvimento de plug-in e, ao mesmo tempo, incluir um pouco de ciência nos seus jogos no Minecraft. Neste artigo, você verá com ampliar o servidor do Spigot com um plug-in que usa os serviços cognitivos do Watson.

A IBM oferece vários serviços do Watson no IBM Cloud que podem ser utilizados para desenvolver soluções cognitivas. Incluem Watson Question and Answer Service, insights de personalidade, The Watson Natural Language Classifier, Tradeoff Analytics e muitos outros serviços. Veja a lista completa de serviços do Watson.

Neste tutorial, você verá como desenvolver um plug-in que use o serviço Watson Q&A para responder a perguntas sobre doenças — e, depois, como combinar esse plug-in com outro plug-in de terceiros do Minecraft que inclua doenças infecciosas para seus aldeões do jogo. Ao combinar os dois, obtém-se um motivo dentro do jogo para aprender como diagnosticar e tratar uma doença, além de como fazê-lo. Essa integração de prova de conceito mostra como é possível combinar plug-ins de terceiros com seus próprios plug-ins para usar o poder do Watson e do IBM Cloud.

Criar um aplicativo do IBM Cloud e obter credenciais do Watson Q&A

Vamos começar. Em primeiro lugar, precisamos obter uma instância do serviço Watson Q&A e obter algumas credenciais dessa instância de serviço para usá-las no nosso novo plug-in. A seguir, iremos desenvolver o plug-in e instalá-lo no Docker, além de realizar o push para o serviço de IBM Container.

Para obter as credenciais relevantes para acessar a instância do Watson Q&A na versão atual do IBM Cloud, precisamos seguir um processo de desvio. Se você estiver programando um aplicativo usando um dos tempos de execução do Cloud Foundry, é possível criar um serviço e, depois, ligá-lo ao seu tempo de execução a fim de obter as credenciais para o serviço, que passam até seu tempo de execução automaticamente por meio de um conjunto de variáveis de ambiente. Entretanto, esse mesmo processo de ligação ainda não funciona de forma tão contínua para containers do Docker; portanto, precisamos introduzir um aplicativo “simulado” que ligamos ao serviço Watson Q&A com o intuito de obter as credenciais certas. Para fazer isso, siga este procedimento:

  1. Efetue login no IBM Cloud usando seu ID IBM e senha. (Caso não tenha um ID IBM, é possível obter um quando se registrar para sua conta para teste grátis do IBM Cloud.)

  2. Crie um novo aplicativo clicando em CREATE APP > Web > SDK for Node.js > Continue.

    Especifique um nome de APLICATIVO que seja único (usamos WatsonSpigotApp no nosso exemplo). Depois de criar o WatsonSpigotApp, retorne para a página Overview (clicando em Visão geral na coluna à esquerda).

  3. Inclua o serviço do Watson no aplicativo que acabou de criar clicando em INCLUIR UM SERVIÇO OU API.

    Printscreen demonstrando a interface de menu do Eclipse com a opção de novo projeto destacada.

  4. Escolha o serviço Watson Question and Answer no catálogo de serviços.

    Printscreen do formulário de preenchimento de novo projeto no Eclipse.

  5. Clique em USE no próximo pop-up para incluir o novo serviço. Observe o nome gerado do serviço (é possível mudá-lo, se quiser) e observe também que ele estava ligado ao WatsonSpigotApp. No canto inferior esquerdo, é possível clicar no botão VIEW DOCS para saber mais sobre o serviço e as APIs REST que podem ser usadas para acessá-lo.

    Printscreen da janela de configurações com o botão para adicionar JARs externos destacado.

  6. Retorne para a visão geral do WatsonSpigotApp clicando em Visão geral na coluna à esquerda. Observe o serviço Question and Answer incluído recentemente. Clique em Mostrar Credenciais sob esse serviço para ver as credenciais necessárias para acessar a instância provisionada do serviço Watson Question and Answer.

    Printscreen da janela de configurações com o arquivo JAR selecionado.

  7. Salve essas credenciais (especificamente, a URL, o nome do usuário e a senha) porque precisará delas mais tarde para se conectar a esse serviço do Watson. Suas credenciais serão únicas — essa amostra mostra somente a forma assumida:

    "url": "https://gateway.watsonplatform.net/question-and-answer-beta/api",
    "username": "some-long-hyphenated-set-of-characters",
    "password": "AVeryL0ngSer1esOfCharact3rs"
    

Desenvolver um plug-in Spigot para usar o serviço Watson Q&A

Como você já tem as credenciais certas, podemos construir nosso plug-in Spigot.

Observação: Todos os códigos mencionados nesta série de tutoriais estão disponíveis no GitHub no mesmo projeto clonado na Parte 1. Caso ainda não tenha feito isso (por exemplo, se veio diretamente para este tutorial), clone o projeto a seguir do GitHub:

git clone  https://github.com/kgb1001001/minecraft-project.git

O diretório minecraft-project/spigot-plugin-watson/ inclui um spigot-plugin-watson.zip, que é um projeto Archive Eclipse que inclui o código mencionado no restante deste tutorial.

No seu ambiente do Ubuntu (que foi usado nas Partes 1, 2 e 3):

  1. Faça o download dos Java archives a seguir no diretório $HOME/refLibs. Serão necessárias nas etapas subsequentes:

  2. Desenvolva o craftbukkit-1.8.8.jar executando as etapas a seguir:

    • cd $HOME/refLibs
    • mkdir minecraft
    • wget "https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar" -O minecraft/BuildTools.jar
    • git config --global core.autocrlf input
    • java -jar minecraft/BuildTools.jar

    Quando essas etapas forem concluídas, você deve ter um craftbukkit-1.8.8.jar no seu diretório.

  3. Inicie o Eclipse:

    ./eclipse/eclipse

    Escolha um diretório da área de trabalho. (O Eclipse grava seus arquivos nesse diretório.)

    Observação: caso o Eclipse seja iniciado sem mostrar o menu File, encerre-o e reinicie-o com o comando a seguir:

    UBUNTU_MENUPROXY=0 ./eclipse/eclipse

  4. Crie um novo projeto selecionando File > New > Java Project.

    Printscreen da janela demonstrando o caminho para criar uma nova pasta.

    Especifique o nome como WatsonSpigotPlugin.

    Printscreen da janela demonstrando o caminho para adicionar um caminho para mover arquivo JAR.

    Clique em Avançar e, em Libraries, clique em Add External Jars….

    Printscreen do Eclipse demonstrando como criar uma nova classe de arquivo.

    Navegue até $HOME/refLibs e selecione craftbukkit-1.8.8.jar.

    Printscreen mostrando o caminho de como adicionar um arquivo como plugin.

    Clique em OK e, em seguida, clique em Concluir na próxima tela. Um novo projeto será criado na sua área de trabalho do Eclipse com o nome WatsonSpigotPlugin.

  5. Em seguida, precisamos incluir alguns Java archives de dependência necessários.

    Crie uma nova pasta no seu projeto WatsonSpigotPlugin e chame-a de lib.

    Printscreen do terminal mostrando o watsonspigot no diretório.

    Copie os Java archives a seguir do seu diretório $HOME/refLibs para o diretório lib que acabou de criar:

    • commons-codec-1.10.jar
    • jackson-core-asl-1.9.13.jar
    • jackson-mapper-asl-1.9.13.jar

    Inclua esses Java archives no caminho de construção do seu projeto; selecione-os no Eclipse, clique com o botão direito do mouse e selecione Build Path > Add to Build Path.

    Screen shot of moving JARs

  6. Crie um novo pacote e nomeie-o como com.ibm.minecraft.spigotplugin.

  7. No pacote com.ibm.minecraft.spigotplugin, crie uma nova classe Java e chame-a de WatsonQA. Isso cria a nova classe e carrega o arquivo no Eclipse.

    Screen shot of creating and loading a new class file

  8. Inclua o código a seguir no seu WatsonQA.java:

    // Begin WatsonQA.java
    
    1)    package com.ibm.minecraft.spigotplugin;
    2)
    3)    import org.bukkit.command.Command;
    4)    import org.bukkit.command.CommandSender;
    5)    import org.bukkit.plugin.java.JavaPlugin;
    6)
    7)    public class WatsonQA extends JavaPlugin {
    8)        // Fired when plugin is first enabled
    9)        @Override
    10)        public void onEnable() {
    11)            getLogger().info("WatsonSpigotPlugin");
    12)        }
    13)        // Fired when plugin is disabled
    14)        @Override
    15)        public void onDisable() {
    16)
    17)        }
    18)
    19)        public boolean onCommand(CommandSender sender, Command cmd, String label,
    20)                String[] args) {
    21)            getLogger().info("command: " + cmd.getName());
    22)            //getServer().dispatchCommand(getServer().getConsoleSender(), cmd.getName());
    23)            if (cmd.getName().equalsIgnoreCase("hello")) {
    24)                sender.sendMessage("Hello Watson");
    25)            }
    26)            if (cmd.getName().equalsIgnoreCase("watson")) {
    27)                if (args.length == 0) {
    28)                    sender.sendMessage("WATSON Rocks");
    29)                    return true;
    30)                }
    31)
    32)                if (args.length >= 1) {
    33)                    StringBuilder str = new StringBuilder();
    34)                    for(int i=0; i < args.length; i++) {
    35)                        str.append(args[i]);
    36)                        if(i < args.length-1) {
    37)                            str.append(" ");
    38)                        }
    39)                    }
    40)                    String question = str.toString();
    41)                    sender.sendMessage("asking Watson: " + question);
    42)                    //String response = SpigotQAAPI.getQAAPIResponse(question);
    43)                    //sender.sendMessage("Watson response: " + response);
    44)
    45)                    return true;
    46)                }
    47)
    48)            }
    49)
    50)            return false;
    51)        }
    52)    }
    
    // End WatsonQA.java
    

    O código de amostra no WatsonQA.java é semelhante ao código de amostra encontrado para começar o desenvolvimento do plug-in para o servidor do Spigot.

  9. Observe os códigos comentados nas linhas 42 e 43. Em seguida, incluiremos o código necessário para essas linhas.
  10. Para fazer isso, no mesmo pacote (com.ibm.minecraft.spigotplugin), crie uma nova classe e chame-a de SpigotQAAPI.
  11. Inclua o código a seguir no seu SpigotQAAPI.java:

    // Begin SpigotQAAPI.java
    
    package com.ibm.minecraft.spigotplugin;
    
    import java.io.BufferedReader;
    
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    
    import org.apache.commons.codec.binary.Base64;
    import org.codehaus.jackson.JsonNode;
    import org.codehaus.jackson.map.ObjectMapper;
    
    public class SpigotQAAPI {
        private static final Logger logger = Logger.getLogger(SpigotQAAPI.class.getName());
    
        /*
         Insert the credentials for the Watson Question and Answer service
         credentials": {
                "url": "https://gateway.watsonplatform.net/question-and-answer-beta/api",
        "username": qa_username,
            "password": qa_password
              }
         */
        static String QAAPI_URL = "https://gateway.watsonplatform.net/question-and-answer-beta/api/v1/question/healthcare";
        static String QA_USERNAME = qa_username;
        static String QA_PASSWORD = qa_password;
        static String BASIC_AUTH = "Basic " + new String(Base64.encodeBase64((QA_USERNAME+":"+QA_PASSWORD).getBytes()));
    
        /*
        * Create HTTP connection
        */
        static public HttpURLConnection createConnection(String address, String method) throws IOException {
        URL url = new URL(address);
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        if (method == "PUT" || method == "POST") {
           connection.setDoOutput(true);
        }
        connection.setRequestMethod(method);
        connection.setRequestProperty("Authorization", BASIC_AUTH);
        connection.setRequestProperty("Accept", "application/json");
        connection.setRequestProperty("Content-Type", "application/json");
    
        return connection;
        }
    
        /*
         * Accepts as input a string of the question text, calls Watson
         * QAAPI and returns the answer back as a String.
         */
        public static String getQAAPIResponse(String questionText) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode resp=null;
        String ans=null;
        System.out.println("QAAPI url: " + QAAPI_URL);
        HttpURLConnection connection;
        try {
    
        connection = createConnection(QAAPI_URL,"POST");
    
        connection.setRequestProperty("X-SyncTimeout", "30");
        questionText = questionText.replaceAll("\"", "");
        questionText = "\"" + questionText + "\"";
        String s = "{ \"question\" : { \"questionText\" : " + questionText + "}}";
    
        JsonNode nd = mapper.readValue(s, JsonNode.class);
    
        connection.setInstanceFollowRedirects(false);
        OutputStream wr = connection.getOutputStream();
        wr.write(nd.toString().getBytes());
        wr.flush();
        wr.close();
        if (connection.getResponseCode() != HttpURLConnection.HTTP_CREATED &&
        connection.getResponseCode() != HttpURLConnection.HTTP_OK &&
        connection.getResponseCode() != HttpURLConnection.HTTP_MOVED_TEMP) {
        throw new RuntimeException("Failed : HTTP error code : "
        + connection.getResponseCode());
        }
    
        BufferedReader br = new BufferedReader(new InputStreamReader(
        (connection.getInputStream())));
    
        String output=null;
        while ((output = br.readLine()) != null) {
            resp = mapper.readValue(output, JsonNode.class);
            if(resp == null) {
            logger.log(Level.WARNING,"system response is null");
            } else {
            ans = resp.get(0).get("question").get("evidencelist").get(0).get("text").toString();
            }
        }
        connection.disconnect();
        } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }
        return ans;
        }
    }
    
    // End SpigotQAAPI.java
    

    A documentação da API REST para o serviço Watson Q&A no IBM Cloud explica que há um corpus ativado para viagem e outro para assistência médica. Por conseguinte, para fazer perguntas em relação ao corpus de assistência médica, a URL precisa ser ampliada com /api/v1/question/healthcare.

    Além disso, lembre-se de substituir qa_username e qa_password pelas credenciais obtidas quando você criou uma instância de serviço Watson QA Criar um aplicativo do IBM Cloud e obter credenciais do Watson Q&A:

    static String QA_USERNAME = qa_username;
    static String QA_PASSWORD = qa_password;
    
  12. Remova os comentários nas duas linhas a seguir no WatsonQA.java:

    42) String response = SpigotQAAPI.getQAAPIResponse(question);
    43) sender.sendMessage("Watson response: " + response);
    
  13. Para fornecer informações sobre o plug-in Watson ao servidor, inclua um novo arquivo na pasta src selecionando src > New > File e nomeie o arquivo como plugin.yml.

    Screen shot of adding plugin.yml

  14. Inclua as linhas a seguir no plugin.yml:

    name: WatsonSpigotPlugin
    main: com.ibm.minecraft.spigotplugin.WatsonQA
    version: 1.0
    
    commands:
      hello:
        description: A new command
      watson:
        description: watson initial command
    
  15. Defina um MANIFEST.MF para fazer referência aos Java archives de dependência para o plug-in. No projeto WatsonSpigotPlugin, crie uma nova pasta e chame-a de META-INF. Na pasta META-INF, crie um novo arquivo e chame-o de MANIFEST.MF.
  16. Inclua as linhas a seguir no MANIFEST.MF. Certifique-se de que a última linha no arquivo seja uma nova linha (retorno de linha).

    Manifest-Version: 1.0
    Main-Class: com.ibm.minecraft.spigotplugin.WatsonQA
    Class-Path: lib/jackson-core-asl-1.9.13.jar lib/commons-codec-1.10.jar lib/jackson-mapper-asl-1.9.13.jar
    
  17. Em uma janela do terminal, crie um diretório a partir do qual executará o servidor do Spigot com o plug-in Spigot do Watson:

    mkdir  $HOME/watsonspigotdir
    
  18. No Eclipse, exporte o projeto WatsonSpigotPlugin para um JAR, conforme segue:

    1. Clique em File > Export
    2. Em Java, selecione JAR File e clique em Avançar
    3. Em Resources to Export, selecione WatsonSpigotPlugin, desmarque .classpath e .project, especifique o destino do Java archive como o mesmo diretório em que o servidor do Spigot ($HOME/watsonspigot) será iniciado e chame-o de watsonqa.jar ($HOME/watsonspigot/watsonqa.jar).
    4. Clique em Avançar (não clique em Finish por enquanto).
    5. Clique em Avançar novamente.
    6. Na página JAR Manifest Specification, lembre-se de selecionar a opção de use existing manifest from workspace.
    7. Clique em Concluir.

    Screen shot of exporting the project into a JAR

  19. Execute o Docker para criar uma nova imagem utilizando o plug-in WatsonSpigotPlugin. Para esta etapa, faremos uma entrega contínua para o diretório $HOME/watsonspigot, que possui dockerfile e watsonqa.jar:

    Screen shot of the watsonspigot directory

  20. Edite $HOME/watsonspigot/dockerfile para incluir as linhas a seguir:

    # Version 0.0.3
    # This version builds a spigot server
    # using the recommended build strategy for spigot
    # This is advantageous in that it's better for plugin development
    # and fits well with the Docker approach
    # it also adds a first Minecraft plugin into the bare spigot server
    #
    FROM ubuntu:14.04
    MAINTAINER Kyle Brown "brownkyl@us.ibm.com”
    RUN apt-get update
    RUN apt-get install -y git
    RUN apt-get install -y default-jdk
    RUN apt-get install -y wget
    RUN mkdir minecraft
    RUN wget "https://hub.spigotmc.org//jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar" -O minecraft/BuildTools.jar
    RUN git config --global core.autocrlf input
    RUN java -jar minecraft/BuildTools.jar
    RUN echo "eula=true" > eula.txt
    RUN mkdir plugins
    ADD watsonqa.jar /plugins/watsonqa.jar
    # Install unzip
    RUN apt-get install -y unzip
    RUN unzip -uo /plugins/watsonqa.jar -d /plugins/
    CMD java -XX:MaxPermSize=128M -Xms512m -Xmx1024m -jar spigot-1.8.8.jar nogui
    EXPOSE 25565
    

    As linhas destacadas em negrito na listagem de código anterior são as principais diferenças em relação aos outros arquivos Docker vistos nos tutoriais anteriores. Efetivamente, essas linhas criam um novo diretório chamado plugins em $HOME/watsonspigot, copiam watsonqa.jar para o diretório plugins, descompactam o arquivo ZIP do Java archive no diretório plugins e, em seguida, executam o servidor do Spigot. Isso é necessário para garantir que o plug-in possa acessar todos os Java archives de dependência necessários que foram copiados no diretório lib no projeto do Eclipse e mencionados no arquivo MANIFEST.MF tal como descrito anteriormente.

  21. Desenvolva uma nova imagem do Docker, conforme segue:

    docker build -t="parallels/watsonspigotplugin" .
    
  22. Execute o servidor do Spigot com o plug-in Watson QA em:

    docker run -i -t -p=25565:25565 parallels/watsonspigotplugin
    

    Se as linhas a seguir forem exibidas, seu servidor do Spigot com o plug-in Watson foi iniciado com sucesso:

    [00:04:07 INFO]: [WatsonSpigotPlugin] Enabling WatsonSpigotPlugin v1.0
    [00:04:07 INFO]: [WatsonSpigotPlugin] WatsonSpigotPlugin
    [00:04:07 INFO]: Done (12.659s)! Para obter ajuda, digite "help" ou
    "?"
    
  23. Conecte seu cliente do Minecraft com seu servidor (tal como descrito nos tutoriais anteriores desta série).
  24. Depois de conectado, faça uma pergunta ao Watson; por exemplo, “O que é diabetes?”. O texto da pergunta é passado para a instância do Watson QA e a resposta é fornecida ao jogador que enviou a questão.

    Screen shot of asking Watson a question

Hospedar o servidor do Spigot com o plug-in WatsonQA no IBM Cloud

Até o momento, verificamos a funcionalidade do servidor do Spigot com o plug-in Watson localmente em um container do Docker. Em seguida, vamos hospedar esse servidor no IBM Cloud.

  1. Em um terminal do Linux, crie um novo diretório $HOME/watsonspigotbluemix:

    mkdir $HOME/watsonspigotbluemix
    
  2. Copie o watsonqa.jar que extraímos para $HOME/watsonspigot:

    cp $HOME/watsonspigot/watsonqa.jar $HOME/watsonspigotbluemix/
    
  3. Crie um arquivo server.properties (vi server.properties):

    #Minecraft server properties
    #(File modification datestamp)
    spawn-protection=16
    max-tick-time=60000
    generator-settings=
    force-gamemode=false
    allow-nether=true
    gamemode=0
    enable-query=false
    player-idle-timeout=0
    difficulty=1
    spawn-monsters=true
    op-permission-level=4
    resource-pack-hash=
    announce-player-achievements=true
    pvp=true
    snooper-enabled=true
    level-type=DEFAULT
    hardcore=false
    enable-command-block=false
    max-players=20
    network-compression-threshold=256
    max-world-size=29999984
    server-port=9085
    server-ip=
    spawn-npcs=true
    allow-flight=false
    level-name=world
    view-distance=10
    resource-pack=
    spawn-animals=true
    white-list=false
    generate-structures=true
    online-mode=false
    max-build-height=256
    level-seed=
    use-native-transport=true
    motd=A Minecraft Server
    enable-rcon=false
    
  4. Crie um dockerfile (vi dockerfile) que inclua o código a seguir:

    # Version 0.0.3
    # This version builds a spigot server
    # using the recommended build strategy for spigot
    # This is advantageous in that it's better for plugin development
    # and fits well with the Docker approach
    # it also adds a first Minecraft plugin into the bare spigot server
    #
    FROM ubuntu:14.04
    MAINTAINER Kyle Brown "brownkyl@us.ibm.com”
    RUN apt-get update
    RUN apt-get install -y git
    RUN apt-get install -y openjdk-7-jre-headless
    RUN apt-get install -y wget
    RUN mkdir minecraft
    RUN wget "https://hub.spigotmc.org//jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar" -O minecraft/BuildTools.jar
    RUN git config --global core.autocrlf input
    RUN java -jar minecraft/BuildTools.jar
    RUN echo "eula=true" > eula.txt
    ADD server.properties ./server.properties
    RUN mkdir plugins
    ADD watsonqa.jar /plugins/watsonqa.jar
    RUN apt-get install -y unzip
    RUN unzip -uo /plugins/watsonqa.jar -d /plugins/
    CMD java -XX:MaxPermSize=128M -Xms512m -Xmx1024m -jar spigot-1.8.8.jar nogui
    EXPOSE 9085
    

    A única diferença em relação ao Dockerfile que criamos antes para executar o servidor do Spigot localmente é que incluímos o arquivo server.properties e expusemos a porta 9085.

  5. O diretório $HOME/watsonspigotbluemix deve ser semelhante ao seguinte:

    Screen shot of the directory

  6. Efetue login no IBM Cloud usando seu ID do IBM Cloud, senha e espaço de desenvolvimento (não é preciso configurar o namespace novamente caso ele já tenha sido configurado):

    cf login
    cf ic login
    cf ic namespace set kozhaya
    
  7. Desenvolva uma nova imagem do Docker:

    docker build -t watsonspigotbluemix .
    
  8. Identifique a imagem criada:

    docker tag watsonspigotbluemix registry.ng.bluemix.net/kozhaya/watsonspigot
    
  9. Realize o push da imagem do Docker para o IBM Cloud:

    docker push registry.ng.bluemix.net/kozhaya/watsonspigot
    
  10. Execute o container do Docker no IBM Cloud:

    cf ic run --name=watsonspigot  --publish=9085
    registry.ng.bluemix.net/Kozhaya/watsonspigot
    

    Quando executado com sucesso, um ID é gerado: 1b5fa8fe-c988-4b64-b238-546d6031da1e

    Screen shot of the returned id

  11. Solicite um endereço IP disponível:

    cf ic ip request
    

    Screen shot of requesting an IP address

  12. Ligue o endereço IP gerado com o container Docker do IBM Cloud executado na etapa 10:

    cf ic ip bind <ip address> watsonspigot
    

    Screen shot of binding the returned IP address to the IBM Cloud Docker container

  13. Verifique se o endereço IP está ligado ao container Docker do IBM Cloud:

    Screen shot of verifying that the IP address is bound to the IBM Cloud Docker container

  14. Conecte o cliente com o servidor do Spigot hospedado no IBM Cloud. Observe o endereço IP no retângulo e o número da porta no oval.

    Screen shot of the IP address and the port number

  15. Faça uma pergunta ao Watson para verificar a funcionalidade:

    /watson "What is Diabetes”
    

    Screen shot of asking Watson a question

Incluir o plug-in Disease e perguntar ao Doutor Watson

Nesta seção, introduzimos um plug-in de terceiros, o plug-in Disease, que permite que os jogadores levem o terror e o medo de doenças contagiosas para a cidade do Minecraft. Com essas doenças no jogo, é possível utilizar o Doutor Watson por meio do plug-in descrito anteriormente para informações sobre a definição e sintomas de tais doenças, assim como as melhores opções de tratamento.

Para incluir o plug-in Disease, precisaremos incluir uma etapa no Dockerfile que usamos antes para criar o plug-in Watson. Isto é, será necessário fazer o download do Java archive para o plug-in Disease e incluí-lo no diretório plugins. Para referência, precisamos editar o Dockerfile (uma cópia está inclusa abaixo) e incluir a linha destacada em negrito (perto da parte inferior da listagem).

# Version 0.0.3
# This version builds a spigot server
# using the recommended build strategy for spigot
# This is advantageous in that it's better for plugin development
# and fits well with the Docker approach
# it also adds a first Minecraft plugin into the bare spigot server
#
FROM ubuntu:14.04
MAINTAINER Kyle Brown "brownkyl@us.ibm.com”
RUN apt-get update
RUN apt-get install -y git
RUN apt-get install -y default-jdk
RUN apt-get install -y wget
RUN mkdir minecraft
RUN wget "https://hub.spigotmc.org//jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar" -O minecraft/BuildTools.jar
RUN git config --global core.autocrlf input
RUN java -jar minecraft/BuildTools.jar
RUN echo "eula=true" > eula.txt
RUN mkdir plugins
ADD watsonqa.jar /plugins/watsonqa.jar
# Install unzip
RUN apt-get install -y unzip
RUN unzip -uo /plugins/watsonqa.jar -d /plugins/
RUN wget "http://dev.bukkit.org/media/files/898/525/Disease-1.7.jar” -O plugings/Disease-1.7.jar
CMD java -XX:MaxPermSize=128M -Xms512m -Xmx1024m -jar spigot-1.8.8.jar nogui
EXPOSE 25565

Com esse Dockerfile, você precisa executar as mesmas etapas executadas anteriormente para desenvolver uma imagem do Docker e executá-la:

  1. Mude para o diretório onde seu Dockerfile está. Para fins de ilustração, iremos supor que estamos no mesmo diretório mencionado antes para iniciar um servidor com o plug-in Watson QA,isto é, $HOME/watsonspigot:

    cd $HOME/watsonspigot
    
  2. Desenvolva uma nova imagem do Docker, conforme segue:

    docker build -t="parallels/diseasewatsonspigotplugin" .
    
  3. Execute o servidor do Spigot com o plug-in Disease que transferimos por download e o plug-in Watson QA, conforme segue:

    docker run -i -t -p=25565:25565 parallels/diseasewatsonspigotplugin
    

    Se as linhas a seguir forem exibidas, seu servidor do Spigot com o plug-in Disease e o plug-in Watson foi iniciado com sucesso.

    Screen shot of starting your Spigot server

    alt

  4. Conecte seu cliente do Minecraft com seu servidor (tal como descrito nos tutoriais anteriores).

Depois de conectado, explore o plug-in Disease e os comandos associados, tais como:

  • /disease help
  • /disease list
  • /disease check
  • /disease infect <player> <disease>

Confira a lista completa de comandos. (Alguns comandos exigem permissão de administrador.)

Agora que o Watson QA para assistência médica também é acessível por meio do plug-in, é possível enviar qualquer pergunta relacionada a doenças para o Doutor Watson. Por exemplo, envie o comando a seguir para perguntar ao Watson sobre as melhores opções de tratamento para pneumonia:

/watson "How to treat Pneumonia”

Screen shot of asking Watson a question

Deixaremos a tarefa de hospedar esse servidor do Spigot com os plug-ins Disease e Watson QA no IBM Cloud como um exercício para o leitor. Você já sabe como combinar vários plug-ins, incluindo serviços do Watson, no seu servidor do Minecraft para criar uma experiência com videogames mais envolvente.

Conclusão

Você já viu como integrar o serviço Watson Q&A em um servidor do Spigot e hospedá-lo em um container Docker no IBM Cloud. Apesar de termos focado no serviço Watson Q&A, é possível usar a mesma abordagem para um jogo mais envolvente usando um ou mais dos outros serviços do Watson, como o Dialog (como pedir uma pizza enquanto joga), Personality Insights (como formar equipes de jogadores), Natural Language Classifier (como entender a intenção do jogador a partir de suas perguntas) e Visual Recognition (como reconhecer sintomas das doenças a partir das imagens).

Aviso

O conteúdo aqui presente foi traduzido da página IBM Developer US. Caso haja qualquer divergência de texto e/ou versões, consulte o conteúdo original.