Conteúdo


Crie plug-ins cognitivos para o Minecraft com o Bluemix, o Docker e o Watson, Parte 1

Executando servidores do Minecraft no Docker

Comments

Conteúdos da série:

Esse conteúdo é a parte # de # na série: Crie plug-ins cognitivos para o Minecraft com o Bluemix, o Docker e o Watson, Parte 1

Fique ligado em conteúdos adicionais dessa série.

Esse conteúdo é parte da série:Crie plug-ins cognitivos para o Minecraft com o Bluemix, o Docker e o Watson, Parte 1

Fique ligado em conteúdos adicionais dessa série.

Qual o único programa Java™ que tem sido usado mais do que qualquer outro programa Java em uma enorme magnitude? Dica: Ele vendeu mais de 70 milhões de cópias desde sua primeira liberação em 2009 em edição beta. A Microsoft comprou recentemente a empresa que criou esse programa por 2,5 bilhões de dólares. Um enorme ecossistema de desenvolvimento tem crescido em torno desse programa e centenas de milhares de pessoas têm sido inspiradas a aprenderem programação em Java — apenas para poder desenvolver extensões para esse programa.

Como você provavelmente já adivinhou pelo título, esse programa é o jogo Minecraft e, por incrível que pareça, essas centenas de milhares de desenvolvedores são predominantemente crianças e adolescentes. O Minecraft tem tido um sucesso fenomenal no mercado, e parte disso deve-se à sua estrutura exclusiva: você compra o cliente (a interface do jogo) comercialmente, mas os servidores são abertos para extensão. Qualquer pessoa pode ter seu próprio servidor de jogos — possibilitando milhares de diferentes opções, conforme são criadas comunidades exclusivas de desenvolvedores do Minecraft na Internet com base em seus interesses e nas coisas que gostam e não gostam.

Mas o servidor não é apenas aberto para download para iniciar seu próprio servidor, ele também é aberto para extensão para pessoas que desejam desenvolver seus próprios complementos para o jogo. Nesta série, vou mostrar como usar o desenvolvimento de plug-in para o Minecraft para ensinar algumas tecnologias e alguns princípios de desenvolvimento específicos.

Você verá como é possível testar facilmente os plug-ins gravados localmente e, em seguida, executar exatamente a mesma configuração, sem nenhuma alteração, em um servidor em nuvem que os seus amigos ("testadores beta") poderão obter e experimentar. Isso será feito usando duas tecnologias específicas — os contêineres do Docker e do IBM Bluemix — e ao longo do caminho, você também verá como configurar o Eclipse e o serviço Bluemix DevOps Delivery Pipeline para desenvolver seus plug-ins e, até mesmo, como definir o desenvolvimento da equipe com o git.

Introdução ao Docker, ao Bluemix e aos contêineres

Antes de prosseguir, vou decodificar o que acabei de dizer para todos os leitores que possam estar familiarizados com o Minecraft e o Java, mas não com o Docker e o Bluemix. Neste primeiro tutorial, vou focar em como configurar um servidor Minecraft local com o Docker, portanto, vamos começar com uma introdução ao Docker.

O Docker pode ser melhor compreendido por meio de uma analogia. O Docker geralmente é mencionado como "um contêiner de remessa de código". E o que isso significa? Pense em como é um contêiner de remessa — eles estão por toda parte— são aquelas caixas retangulares metálicas em caminhões, vagões de trem e, principalmente, em grandes navios, chamados navios de contêiner, que carregam centenas deles de cada vez entre os portos.

Os contêineres de remessa revolucionaram a maneira de transportar as coisas entre os países. Então suponhamos que você fabrique smartphones. Você deseja transportar milhares deles da sua fábrica na Coreia para uma loja de eletroeletrônicos em Toronto, no Canadá. No passado, essas caixas de telefones provavelmente precisariam ser empacotadas e desempacotadas muitas vezes, pois as caixas eram transportadas de caminhão em caminhão e de navio em navio, com inúmeras paradas em armazéns ao longo do caminho. Sempre que uma caixa era empilhada e desempilhada, havia uma chance de danificação ou perda. Além disso, o trabalho de empilhar e desempilhar era demorado e caro. Atualmente, as caixas são carregadas uma única vez em um grande contêiner de aço na fábrica e o contêiner é transportado por um guindaste do caminhão para o navio e novamente para o caminhão que levará à loja de eletroeletrônicos — tudo isso sem ser desempilhado e aberto nenhuma vez.

O Docker faz o mesmo com o código. A nossa maneira atual de desenvolver e executar um código (como Java) é desenvolver o código em um ambiente de desenvolvimento. Em seguida, mover o código-fonte para outro sistema onde ele será compilado e "construído" em um sistema executável (um arquivo WAR ou um arquivo JAR). No entanto, esse código executável precisa de muita infraestrutura (como um Java Runtime específico, talvez um determinado servidor de aplicativos e inúmeros arquivos JAR de software livre) para ser executado. Em seguida, tudo isso precisa ser movido e remontado muitas outras vezes no servidor de teste de unidade, no servidor de teste de sistema e em cada um dos servidores de produção. Em cada estágio existe a chance de algo dar errado na etapa de "compactar e descompactar". É possível escolher uma versão errada ou esquecer algo no caminho — levando a erros que, muitas vezes, são difíceis de rastrear.

O Docker permite empacotar um sistema em execução inteiro — diretamente até o sistema operacional — em um único pacote leve (não por acaso chamado de contêiner) que pode ser movido de um local para o outro. Nada é deixado de fora, e nada é quebrado durante a movimentação.

O papel do Bluemix é permitir que os contêineres do Docker sejam usados e executados não apenas na máquina local, mas também na nuvem possibilitando o acesso de outras pessoas. O IBM Bluemix Containers fornece um caminho fácil para fazer isso.

Nesta série de tutoriais, as primeiras duas coisas que veremos, é como fazer com que um servidor do Minecraft seja executado localmente no Docker e, em seguida, fazer com que esse mesmo contêiner do Docker seja executado no Bluemix.

Compre e instale o cliente Minecraft

Como mencionei anteriormente, a genialidade do Minecraft é que eles vendem o cliente a milhões de jogadores e abriram o código-fonte para que os usuários possam ampliar o jogo e configurar servidores do Minecraft para jogos com vários jogadores. A primeira etapa é comprar e instalar o cliente Minecraft. É possível encontrar instruções de como instalar o cliente na maioria dos sistemas operacionais no site do Minecraft.

Vamos desenvolver e executar nosso servidor no Ubuntu, mas é possível executar o cliente Minecraft em qualquer sistema operacional suportado. Tudo o que você precisa saber é o endereço IP do servidor e as necessidades do cliente para que ele possa contatar esse endereço IP. Na verdade, eu comprei o cliente Mac Minecraft nativo e, em seguida, o conectei aos meus servidores de desenvolvimento em execução em uma máquina virtual VMWare no meu desktop desse cliente.

Instale e configure o Docker

A próxima etapa é fazer o download e configurar o Docker e as outras partes do software necessárias para que esse conjunto de instruções funcione. Vamos começar com o Docker. Nesta série vou mostrar como instalá-lo e configurá-lo para o Ubuntu Linux 14.03.3 LTS. Se você desejar fazer isso em um sistema operacional diferente, consulte as instruções de instalação do Docker para a plataforma apropriada.

Apesar de estarmos usando o Ubuntu 14.04.3 LTS, é possível usar qualquer sistema operacional que ofereça suporte às ferramentas do Docker e do Cloud Foundry a partir do Cloud Foundry e da IBM, incluindo o Windows e o Linux. Eu recomendo usar o Ubuntu porque pela minha experiência, é mais limpo e mais simples realizar esse tipo de desenvolvimento diretamente no Linux. Felizmente, é fácil fazer o download e criar uma imagem do Linux no VMWare ou no VirtualBox em vários outros sistemas operacionais, então recomendo que isso seja feito como base. Ao fazer isso (ou se você apenas estiver instalando o Ubuntu Linux no seu hardware), eu também recomendo a configuração de uso de pelo menos 2 GB de RAM e 2 núcleos — menos que isso poderá causar falha posterior.

Neste exemplo, mostrarei como configurar e executar o Docker dentro de uma imagem do Ubuntu executada em um ambiente VMWare. Se você escolher usar o Virtualbox ou outro Hypervisor, algumas das tarefas externas ao Ubuntu serão um pouco diferentes.

Instale o Docker no Ubuntu

  1. Insira os seguintes comandos no aplicativo "terminal" no Ubuntu para instalar o 1.7.0:
    wget -qO- https://get.docker.com/ | sed 's/lxc-docker/lxc-docker-1.7.0/' | sh
  2. O primeiro comando faz o download do Docker e instala-o no Ubuntu. No entanto, na instalação padrão, o Docker requer que seus comandos sejam executados com privilégios raiz. Para evitar isso e usar um ID diferente, execute o comando a seguir:
    sudo usermod -aG docker <your nonroot login id>
  3. Depois de emitir o comando, efetue logout do Ubuntu e efetue login novamente.

Instale as ferramentas de linha de comandos do Cloud Foundry

Em seguida, será necessário instalar as ferramentas de linha de comandos do Cloud Foundry. Elas não serão usadas neste primeiro tutorial, mas serão usadas no terceiro, portanto, é interessante instalá-las agora durante a configuração da sua imagem do Ubuntu. Se estiver em qualquer outra plataforma, será necessário acessar o GitHub para instalar as ferramentas corretas no seu navegador, mas esse procedimento funcionará no Ubuntu.

  1. Na linha de comandos, digite a linha a seguir para fazer download das ferramentas de linha de comandos do Cloud Foundry:
    wget
    "https://cli.run.pivotal.io/stable?release=debian64&version=6.12.3&source=github-rel"
    -O cf-cli_amd64.deb
  2. Digite o seguinte na linha de comandos para instalar as ferramentas:
    sudo dpkg -i cf-cli_amd64.deb
  3. Instale o plug-in IBM para as ferramentas do Cloud Foundry que permitirão fazer upload e executar as imagens do Docker posteriormente. Faça isso no Ubuntu digitando:
    cf install-plugin https://static-ice.ng.bluemix.net/ibm-containers-linux_x64
  4. Depois de instalar o plug-in IBM Containers, será necessário reiniciar o Docker. Para fazer isso, emita o seguinte comando no terminal:
    sudo service docker restart
  5. Agora que você já transferiu por download e instalou o Docker e as ferramentas do Cloud Foundry para o Docker (que permitirão realizar coisas interessantes com os dois!), é possível fazer o download do código de amostra que examinaremos no restante deste tutorial e nos dois tutoriais seguintes. O código de amostra está disponível em git e pode ser transferido por download com o seguinte comando:
    git clone  https://github.com/kgb1001001/minecraft-project.git

Sobre o Dockerfile básico do Minecraft

O Docker pode ser executado de algumas maneiras diferentes. É possível simplesmente iniciar um contêiner no Docker e começar a usá-lo e, em seguida, fazer mudanças no contêiner em execução e salvar essas mudanças como um novo arquivo de imagem. No entanto, lembre-se de que um dos motivos do nosso interesse no Docker é evitar os problemas criados pelas alterações manuais, portanto, essa abordagem não nos ajuda muito! No nosso caso, vamos usar uma abordagem diferente que o Docker também suporta, que é o Dockerfile. Um Dockerfile é um conjunto de comandos que cria uma imagem de maneira repetitiva. Assim, se o Dockerfile for executado em máquinas diferentes, ele sempre apresentará o mesmo resultado. Pense nele como um "conhecimento de embarque" que informa o que há dentro da imagem do Docker (e, portanto, dentro dos contêineres que você está construindo).

O propósito do nosso primeiro arquivo do Docker é simplesmente ver como é fácil iniciar a execução de um servidor Minecraft localmente no Docker. Então vamos analisar o Dockerfile primeiro. Para visualizar o Dockerfile, digite os comandos a seguir:

cd minecraft-project
cat minecraft/dockerfile

Os conteúdos do Dockerfile são mostrados abaixo. Vamos percorrer as partes, uma de cada vez.

# Version 0.0.1
# This docker file builds a basic minecraft server
# directly from the default minecraft server from Mojang
#
FROM ubuntu:14.04
MAINTAINER Kyle Brown “brownkyl@us.ibm.com”
RUN apt-get update
RUN apt-get install -y default-jdk
RUN apt-get install -y wget
RUN mkdir minecraft
RUN wget -O minecraft/minecraft_server.jar \ 
https://s3.amazonaws.com/Minecraft.Download/versions/1.8.8/minecraft_server.1.8.8.jar
RUN echo "eula=true" > eula.txt
CMD java -Xms512m -Xmx1024m -jar minecraft/minecraft_server.jar nogui
EXPOSE 25565
  • O primeiro comando no Dockerfile (após alguns comentários úteis precedidos por hashtag) é o FROM. Ele mostra a partir de qual imagem essa imagem do Docker deve ser construída. Uma das coisas boas do Docker é que as imagens são construídas a partir de outras imagens, portanto, se outra pessoa desejar usar sua imagem e ampliá-la de alguma forma, isso será fácil de fazer dentro de certos limites. No nosso caso, estamos construindo a imagem do Docker a partir da imagem mais recente do Ubuntu 14.04, do repositório Dockerhub.
  • MAINTAINER simplesmente informa quem é responsável por gravar e manter esse arquivo.
  • Os próximos três comandos são os mais interessantes. Um comando RUN é exatamente o mesmo que executar um comando na linha de comando do Linux. Portanto, nos próximos três comandos, a imagem atual do Ubuntu será atualizada de acordo com as correções mais recentes do Ubuntu e, em seguida, serão instalados o Java JDK padrão e o utilitário wget. Depois disso, vou criar um diretório chamado minecraft e fazer o download do arquivo minecraft_server.jar a partir do site de armazenamento Amazon S3, no qual ele está armazenando, e colocá-lo no diretório minecraft.
  • Meu próximo comando cria um arquivo chamado eula.txt que mostra que o usuário desse servidor aceitou o contrato EULA.
  • Agora vamos ao ponto central do que queremos fazer. A instrução CMD executa tudo o que estiver depois da palavra-chave CMD quando a imagem do Docker criada por esse Dockerfile é executada. Isso é importante — a instrução RUN é executada imediatamente quando o Dockerfile é construído ou transformado de um Dockerfile de instruções em uma imagem final do Docker. A instrução CMD apenas será executada quando o contêiner criado a partir dessa imagem for iniciado.
  • A instrução final é EXPOSE. A palavra-chave EXPOSE indica quais portas TCP/IP visualizadas de dentro do contêiner do Docker podem ser acessadas de fora do contêiner do Docker quando ele é executado. Por padrão, não é possível acessar qualquer uma das portas de dentro do contêiner do Docker — isso significa que ele é seguro por padrão e é necessário escolher o que expor e quando.

Como mencionei anteriormente, existem duas etapas para executar um contêiner: construir o Dockerfile em uma imagem e, em seguida, executar a imagem como um contêiner. Mas primeiro, é necessário decidir um nome para o repositório do Docker. Geralmente, eu uso o mesmo que meu nome de login no Ubuntu, portanto, sempre que aparecer <directory> nas próximas instruções, substitua-o pelo seu ID de login (por exemplo, o meu é "kbrown").

  1. Vamos começar emitindo os seguintes comandos no terminal:
    cd minecraft
    sudo docker build -t="<directory>/minecraft188" .

    Observe o ponto (.) importante no final do último comando. Esse comando cria uma nova imagem a partir das instruções dentro do Dockerfile localizado no diretório (".") atual — o mesmo Dockerfile que vimos anteriormente.

    O resultado é que todas as etapas são executadas de uma vez, com diversas informações intermediárias sobre as etapas emitidas como resultado. Esse comando pode demorar vários minutos ou mais, dependendo da velocidade da conexão de rede, porque muitos dos comandos no Dockerfile (como os comandos apt-get) precisam fazer download de novas versões de software na imagem do Docker. Se tudo funcionar corretamente, a última linha após a execução bem-sucedida de RUN java -jar minecraft/BuildTools.jar será:

    Successfully built 764c25d251f6

    Observe que o ID de 12 dígitos no final da mensagem será diferente, mas o importante é aparecer "Successfully built".

  2. Agora chegou a hora da verdade — está tudo pronto para verificar se é possível executar um servidor do Minecraft dentro do Docker! Para tentar, emita o comando a seguir, novamente substituindo o nome de login por <directory>.
    sudo docker run -i -t -p=25565:25565 <directory>/minecraft188

    Ao concluir, uma mensagem como esta deverá aparecer na parte inferior do console:
    [14:10:43] [Server thread/INFO]: Done (6.086s)! Para obter ajuda, digite "help" ou "?"
  3. Estamos quase no ponto em que é possível testar a execução do novo servidor do Minecraft no Docker, mas ainda precisamos de mais informações. Quando uma máquina virtual é executada no VMWare, ela é executada no endereço de rede visível para a máquina host, mas não para o restante do mundo. No entanto, para fazer contato com quaisquer programas em execução no endereço de rede, primeiro é necessário descobri-los. Como estamos ocupando nossa janela de terminal atual com a execução do Minecraft dentro do Docker, abra uma segunda janela, acessando o menu Arquivo do Terminal do Ubuntu e selecionando Abrir terminal.
  4. Na segunda janela de terminal, digite o seguinte comando:
    ifconfig eth0 | grep “inet addr”

    Quando esse comando for executado, uma saída semelhante a esta será emitida:

    inet addr:172.16.103.242  Bcast:172.16.103.255  Mask:255.255.255.0

    O endereço de Internet imediatamente após inet addr: é aquele que será usado no cliente Minecraft no sistema operacional para fazer contato com o novo servidor.

Configure o cliente Minecraft

Ok, agora vem a parte divertida!

  1. Inicie o cliente Minecraft e clique no botão grande de execução na primeira tela (a que fornece informações sobre as próximas liberações e assim por diante).
  2. Na tela de inicialização do Minecraft que aparece, escolha Multijogadores. Minecraft Start screen
    Minecraft Start screen
  3. Na tela Jogar com multijogadores que aparece, clique em Incluir servidor. Play Multiplayer screen
    Play Multiplayer screen
  4. Na tela Incluir (ou editar) informações do servidor, insira o endereço IP encontrado na VM anteriormente, e assegure-se de incluir :25565 no final do endereço de rede IP do servidor (25565 é a porta exposta a partir do contêiner do Docker). Add (or Edit) Server Info screen
    Add (or Edit) Server Info screen
  5. Clique em Concluído, em seguida, na tela Jogar com multijogadores, clique em Associar servidor no novo servidor.

    Agora, a execução deverá ocorrer no seu novo servidor local no Docker!

  6. Depois de experimentar um pouco e, talvez, construir algumas coisas e derrubar alguns monstros em Minecraft, acesse a janela do Terminal do Ubuntu na qual o servidor está sendo executado (no Docker) e pressione control + C para finalizar o contêiner do Docker.

Sobre o Dockerfile do Spigot

Com certeza é muito interessante poder hospedar seu próprio servidor local do Minecraft como foi mostrado acima, mas esse não é o ponto principal desta série de tutoriais. O problema é que o Minecraft, da maneira em que é fornecido diretamente pela Mojang não é muito extensível do lado do servidor. O que eu desejo mostrar nesta série é como usufruir de alguns dos serviços do Watson fornecidos pelo Bluemix, o que significa que precisamos de um servidor do Minecraft que seja aberto à modificação. Em 2010, um grupo de desenvolvedores criou uma API exatamente para esse tipo de servidor — seu nome é Bukkit API, e ela permite criar extensões como plug-ins do Minecraft. Já houve várias implementações da Bukkit API, mas a mais comum é a implementação do Spigot. O Spigot não é apenas a versão do servidor do Minicraft mais modificada, ele também tem sido melhorado de várias formas para aprimorar a eficiência e o desempenho.

Vamos usar o Spigot como nosso servidor, então em vez de basear o restante dos exemplos no servidor genérico do Minecraft do exemplo anterior, vamos usar o servidor Spigot a partir de agora. Vamos examinar o Dockerfile mostrado abaixo e percorrer as diferenças para ver como isso seria feito.

Observe que os comandos nesse Dockerfile são adaptados das instruções de construção localizadas no website do Spigot. Caso ocorra algum problema com esse Dockerfile, possivelmente causado pelas mudanças, consulte essa página novamente — ela é a mais completa fonte de informações sobre como construir servidores Spigot.

Vamos consultar o novo Dockerfile:

# Version 0.0.2
# 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
#
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
CMD java -XX:MaxPermSize=128M -Xms512m -Xmx1024m -jar spigot-1.8.8.jar nogui
EXPOSE 25565

Vários aspectos desse arquivo devem ser familiares a você, porque são iguais aos do exemplo de servidor básico do Minecraft visto anteriormente. Por exemplo, os comandos para atualizar o Ubuntu Linux e instalar o JDK padrão são iguais. No entanto, esse Dockerfile também instala a ferramenta Git, que já usamos no Linux.

A verdadeira mudança ocorre na linha que executa o wget para buscar o arquivo dos servidores SpitgotMC (em vez dos servidores Amazon S3 que hospedam o servidor do Minecraft básico). O que buscamos do servidor SpigotMC não é um arquivo JAR simples a ser executado depois, mas um arquivo intermediário usado para realmente construir o arquivo JAR final. Isso tem a vantagem de permitir sempre obter a versão mais recente do servidor Spigot, sem precisar alterar ainda mais o código no Dockerfile. Também é necessário fazer algumas mudanças no comportamento padrão do git, que é usado no processo de construção, para lidar com as diferenças na maneira em que os retornos ou feeds da linha são manipulados entre o Microsoft Windows (no qual ocorre grande parte do desenvolvimento do Spigot) e o Linux.

Para ver como o processo de construção é diferente, emita os seguintes comandos no mesmo diretório no qual o contêiner do Minecraft foi executado anteriormente.

cd ../spigot

sudo docker build -t="<directory>/spigot188” .

Observe que a construção desse arquivo será muito demorada! Mas o lado bom é que a natureza em camadas do Docker permitirá que ele não precise sempre construir todas as etapas intermediárias. Para entender isso, execute esse comando mais uma vez. Essa execução deverá ser muito mais rápida! O motivo é encontrado na saída:

Step 7 : RUN wget "https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar" -O minecraft/BuildTools.jar
 ---> Using cache
 ---> fdf1e118f298
Step 8 : RUN git config --global core.autocrlf input
 ---> Using cache
 ---> 5a130309c12c
Step 9 : RUN java -jar minecraft/BuildTools.jar
 ---> Using cache
 ---> 516e9fb02428

Observe que após cada comando aparece Using cache. Quando o Docker executa uma etapa em um Dockerfile, ele armazena o resultado em cache como uma nova imagem. Em Parte 2, ao começar a criar plug-ins para o Spigot, veremos que não é necessário passar pelas partes lentas do processo de criação — atualização do Ubuntu e criação do arquivo do Spigot — novamente!

Para ver se a criação foi bem-sucedida, emita o comando a seguir:

sudo docker run -i -t -p=25565:25565 <directory>/spigot188

Se aparecer uma mensagem como esta:

[21:16:17 INFO]: Done (11.170s)! For help, type "help" or "?"

O segundo servidor do Minecraft foi criado com sucesso — desta vez, extensível! Tente conectar o cliente Minecraft ao novo servidor (ele está no mesmo endereço de rede que o exemplo anterior, portanto, não é necessário alterar) e verifique se tudo funciona corretamente.

Conclusão

Você concluiu a Parte 1 desta série de tutoriais. Você aprendeu como o Docker funciona e como ele é útil para os desenvolvedores do Minecraft, e viu alguns exemplos detalhados de alguns Dockerfiles para criar servidores locais do Minecraft. Em Parte 2, você aprenderá como criar plug-ins para o servidor Spigot e verá um exemplo de um plug-in em execução no servidor.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing, Tecnologia Java, Cognitive computing
ArticleID=1025971
ArticleTitle=Crie plug-ins cognitivos para o Minecraft com o Bluemix, o Docker e o Watson, Parte 1: Executando servidores do Minecraft no Docker
publish-date=01222016