Criando um container com Java e Maven usando Docker e Ubuntu

O herói de antigamente, quando eu comecei com Linux e BSD, era o sysadmin.  Um lobo solitário que cuidava de um ou mais servidores com vários scripts de automação.

Essa figura desapareceu e cedeu lugar à padronização e máquinas virtuais.  E as máquinas virtuais estão cada vez mais dando lugar aos containers.

Então a "arte" de fazer scripts está praticamente morrendo com poucos sysadmins ainda estudando perl, python, awk, etc.  Mas mesmo na criação de containers é possível colocar scripts em prática e de forma proveitosa.  Seriam o sysadmins 3.0.

Nesse sentido precisei criar um container pra rodar alguns programas em Java.  Criei o container baseado no Ubuntu 16.04, que é a versão que tenho no laptop de trabalho e com Maven e Java.  Maven é uma ferramenta de construção de Java parecida com pip no Python, CPAN no Perl, npm no node.js e rebar3 no Erlang.  Ele baixa as dependências nas versões desejadas e compila tudo pra gerar seu arquivo jar.  E também pode ser usado pra criar regras como de unittest.

Mas minha razão pra escrever esse post não é o Maven, que tem muitos outros artigos específicos muito bem escritos.  É sobre o Java.  Eu preciso rodar os meus programas com o JDK da Oracle.   E como automatizar?  Esse é o ponto dos scripts que comentei acima e razão desse artigo, de como usar ainda hoje em dia.  Como o download do JDK da Oracle exige aceitação dos termos de uso, é preciso fazer isso dentro do script (através de cookies).  O resto, é container puro.

O arquivo Dockerfile que criei é esse aqui:

FROM ubuntu:16latest

ENV container docker
ENV DEBIAN_FRONTEND noninteractive

RUN apt-get install -y \
        build-essential \
        lsb-release \
        tar \
        wget \
        unzip \
        sudo \
        git \
        curl \
        createrepo \
        java-package \
        fakeroot \
        maven

RUN apt-get install -y \
        libgtk-3-0 \
        libcairo-gobject2

RUN JAVA_URL=$(curl -sS http://www.oracle.com/technetwork/java/javase/downloads/index.html | \ 
                grep -i href | \
                grep "Download JDK" | \
                head -1 | \
                 tr " " "\n" | \
                grep href | \
                sed "s|.*href=\"\([^\"].*[^\"]\)\".*|\1|" ); \
        JDK_URL=$(curl -sS http://www.oracle.com$JAVA_URL | \
                grep -i "^downloads.*linux.*tar.gz.*" | \
                tr " ," "\n" | \
                grep http | \
                sed "s/.*\(http\)/\1/;s/\"//g" ); \
        curl \
                -SLkO \
                --header "Cookie: oraclelicense=accept-securebackup-cookie" \
                -# \
                $JDK_URL ; \
        linux_java=$(basename $JDK_URL) ; \
        version=$(echo $linux_java | sed "s/.*-\([0-9][^_]*\)_.*/\1/" | cut -d "." -f 1) ; \
        new_name=jdk-${version}-linux-x64.tar.gz ; \
        deb_name=oracle-java${version}-jdk_${version}_amd64.deb; \
        mv $linux_java /home/$new_name

# uid=2000(jenkins) gid=2000(jenkins) groups=2000(jenkins),999(ssh-allowed),130(libvirtd),131(kvm),998(docker)
RUN groupadd -g 2000 jenkins
RUN useradd -g 2000 -u 2000 -m jenkins

RUN su - jenkins -c "yes Y | fakeroot make-jpkg /home/jdk-*-linux-x64.tar.gz" 
RUN dpkg -i /home/jenkins/oracle-java*deb
RUN JAVA_HOME=$(update-java-alternatives -l | grep oracle | tail -1 | awk '{print $NF}') ; \
        JAVA_VERSION=$(update-java-alternatives -l | grep oracle | tail -1 | awk '{print $1}') ; \
        cd $JAVA_HOME; \
        ln -s jre .; \
        update-java-alternatives -s $JAVA_VERSION; \
        update-alternatives --install /usr/bin/java java $JAVA_HOME/bin/java 1; \
        update-alternatives --set java $JAVA_HOME/bin/java

Eu tenho um outro container chamado ubuntu:16latest que é um Ubuntu 16.04 com apt dist-upgrade pra ter a versão mais recente.  Eu geralmente adiciono o usuários jenkins pra poder rodar os containers dentro do jenkins. 

Uma vez feita a configuração, basta construir o container.  Como tenho vários arquivos pra fazer essas construções, eu geralmente salvo como Dockerfile.<distro>_<aplicativo>.  Nesse caso específico salvei num arquivo Dockerfile.ubuntu_java.  Para construir o container então:

docker build -t ubuntu:java -f Dockerfile.ubuntu_java . 

Feito o container e salvo com a tag ubuntu:java, basta somente chamar o container pra rodar seus programas em java ou compilar.

helio@linux:~/DockerBuilds$ docker run -it ubuntu:java java -version 
java version "10.0.1" 2018-04-17 
Java(TM) SE Runtime Environment 18.3 (build 10.0.1+10) 
Java HotSpot(TM) 64-Bit Server VM 18.3 (build 10.0.1+10, mixed mode)

Daí pra frente é usar o Java como se estivesse instalado localmente.

Fontes:

1. https://wiki.debian.org/JavaPackage

2. https://www.debian.org/doc/manuals/debian-java-faq/ch5.html

Comparação de um curso profissional de Docker, Kubernetes e containers com comunidade

Tive a oportunidade de participar de um curso profissional de containers oferecido dentro da empresa.  Já tive oportunidade de participar de outro curso ministrado pela mesma escola sobre OpenStack numa outra vez.  Material de primeira, laboratório completo e explicações concisas.  Resolvi escrever um pouco pra quem busca algo nesse sentido pra saber se realmente vale a pena.

Meu conhecimento anterior de Dockers veio todo de documentos gerados por comunidade de usuários e pelo próprio site do Docker.  Eu já uso Docker faz alguns anos e com bastante desenvoltura.  Muita coisa que preciso fazer já é em containers.  Durante o curso percebi que realmente não tinha muita novidade.  O uso básico de docker com "run", "images", "tag", etc é exatamente o mesmo.

Uma diferença notável que eu não conhecia foi a referência quanto à OCI, Open Container Iniciative, que tem agora um binário "runc" que substituirá o comando "docker" pra criar uma abstração genérica no manuseio de containers.  Os argumentos são exatamente os mesmo que do "docker".  Então um "docker run -it ubuntu:latest bash"  funciona com um "runc run -it ubuntu:latest bash".  Parte disso é pra facilitar o uso com kubernetes.

Agora sobre kubernetes, eu não conhecia tão a fundo.  Sempre usei um básico do básico do básico com minikube na maioria das vezes.  Já tinha mexido com Jagger pra alguma monitoração de tempo em containers, mas nada como vi no curso.  O laboratório funcionando perfeitamente e com vários exercícios.   Mas várias vezes consultamos a documentação online do kubernetes, ou seja, a documentação já disponível é riquíssima.   Mesmo em alguns pontos o material didático estava bem atrás dos comandos disponíveis no último release de kubernetes. 

E o material do curso?  Sinto mas é um material copyrighted que não pode ser distribuído.  E deixaram isso bem claro.  Mas eu pessoalmente acho que a documentação com tutoriais disponíveis cobrem muito bem tudo que estava descrito ali.

Vale então fazer um curso pago de containers?  Eu diria que depende.  Se tem tempo, é possível aprender tudo sozinho em seu próprio computador.  Mas se tiver uma necessidade mais imediata de resultados, sim cursos serão um bom acelerador nessa direção.

Qualquer que seja sua decisão, keep calm and runc -it run.

Corrigindo as teclas de rolagem em GTK

Já teve problemas com a barra de rolagens (ou scrolls)?  Não?  Pois eu tive por muito tempo.

Como uso KDE, aplicativos baseados em GTK teimam em ignorar os padrões que seleciono e fazem as coisas da forma que querem.  Talvez por isso eu não use Gnome. 

Mas esse problema vem me atormentando desde que foi lançado o GTK3.  Faz o quê?  Uns 5 anos?  As teclas de rolagem estavam com um padrão de que apareciam somente quando o mouse passava por cima.  Irritante.  Não sei quem teve essa ideia, mas eu nunca gostei.  Só que não conseguia mudar.  E eu não dei muita importância ao fato já que no fim conseguia fazer o que precisava e isso era algo pequeno.

E hoje finalmente eu cheguei no ponto de me incomodar e procurar um solução, pois no inkscape é onde esse treco incomoda mais.  Os botões de rolagem ficam se sobrepondo entre o da imagem e da paleta de cores.  Às vezes queria mover, fazia no outro.

E até que não foi algo tão complicado quanto eu esperava.  Como já imaginava, era algo configurável via interface gráfica no caso de estar usando Gnome ou Unity.  Mas pra quem não os têm, via linha de comando basta usar o seguinte: 

gsettings set com.canonical.desktop.interface scrollbar-mode normal

Não gostou e quer voltar ao padrão antigo (por mais que eu não entenda esse tipo de decisão)?

gsettings set com.canonical.desktop.interface scrollbar-mode overlay-auto

É bem simples.  Sofri à toa por besteira.

Linux-4.14 e VirtualBox

Eu gosto de usar os kernels mais recentes e compilar minhas próprias versões.  Às vezes adiciono patches pra melhorar resposta de temporeal, às vezes um suporte pra AUFS no docker.

Atualmente estou com o 4.14-rc2, um pouco antigo nesse momento mas que me deu um uptime de 25 dias sem problemas até agora.

Linux elxaf7qtt32 4.14.0-rc2-helio #12 SMP PREEMPT Fri Sep 29 13:50:19 CEST 2017 x86_64 x86_64 x86_64 OSI/Linux

(é... troquei GNU/Linux por OSI/Linux... por diversão e usando sed na saída do uname)

E descobri que o VirtualBox versão 5.2 simplesmente não consegue rodar o comando /sbin/vboxconfig.  Olhando o erro um pouco mais de perto pelo log:

  gcc -Wp,-MD,/tmp/vbox.0/linux/.SUPR0IdcClient-linux.o.d  -nostdinc -isystem /usr/lib/gcc/x86_64-linux-gnu/5/include -I./arch/x86/include -I./arch/x86/include/generated  -I./include -
I./arch/x86/include/uapi -I./arch/x86/include/generated/uapi -I./include/uapi -I./include/generated/uapi -include ./include/linux/kconfig.h -D__KERNEL__ -Wall -Wundef -Wstrict-prototyp
es -Wno-trigraphs -fno-strict-aliasing -fno-common -fshort-wchar -Werror-implicit-function-declaration -Wno-format-security -std=gnu89 -fno-PIE -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -
mno-avx -m64 -falign-jumps=1 -falign-loops=1 -mno-80387 -mno-fp-ret-in-387 -mpreferred-stack-boundary=3 -mskip-rax-setup -mtune=generic -mno-red-zone -mcmodel=kernel -funit-at-a-time -
DCONFIG_X86_X32_ABI -DCONFIG_AS_CFI=1 -DCONFIG_AS_CFI_SIGNAL_FRAME=1 -DCONFIG_AS_CFI_SECTIONS=1 -DCONFIG_AS_FXSAVEQ=1 -DCONFIG_AS_SSSE3=1 -DCONFIG_AS_CRC32=1 -DCONFIG_AS_AVX=1 -DCONFIG
_AS_AVX2=1 -DCONFIG_AS_AVX512=1 -DCONFIG_AS_SHA1_NI=1 -DCONFIG_AS_SHA256_NI=1 -pipe -Wno-sign-compare -fno-asynchronous-unwind-tables -fno-delete-null-pointer-checks -O2 --param=allow-
store-data-races=0 -DCC_HAVE_ASM_GOTO -Wframe-larger-than=1024 -fstack-protector-strong -Wno-unused-but-set-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-var-tracki
ng-assignments -g -gdwarf-4 -pg -mfentry -DCC_USING_FENTRY -Wdeclaration-after-statement -Wno-pointer-sign -fno-strict-overflow -fconserve-stack -Werror=implicit-int -Werror=strict-pro
totypes -Werror=date-time -Werror=incompatible-pointer-types -Werror=designated-init -include /tmp/vbox.0/include/VBox/SUPDrvMangling.h -fno-pie -I/lib/modules/4.14.0-rc2-helio/build/i
nclude -I/tmp/vbox.0/ -I/tmp/vbox.0/include -I/tmp/vbox.0/r0drv/linux -D__KERNEL__ -DMODULE -DRT_OS_LINUX -DIN_RING0 -DIN_RT_R0 -DIN_SUP_R0 -DVBOX -DRT_WITH_VBOX -DVBOX_WITH_HARDENING 
-Wno-declaration-after-statement -DRT_ARCH_AMD64 -DVBOX_WITH_64_BITS_GUESTS  -DMODULE  -DKBUILD_BASENAME='"SUPR0IdcClient_linux"'  -DKBUILD_MODNAME='"vboxnetflt"' -c -o /tmp/vbox.0/lin
ux/.tmp_SUPR0IdcClient-linux.o /tmp/vbox.0/linux/SUPR0IdcClient-linux.c
  if [ "-pg" = "-pg" ]; then if [ /tmp/vbox.0/SUPR0IdcClient.o != "scripts/mod/empty.o" ]; then ./scripts/recordmcount  "/tmp/vbox.0/SUPR0IdcClient.o"; fi; fi;
(cat /dev/null;   echo kernel//tmp/vbox.0/vboxnetflt.ko;) > /tmp/vbox.0/modules.order
  if [ "-pg" = "-pg" ]; then if [ /tmp/vbox.0/linux/SUPR0IdcClient-linux.o != "scripts/mod/empty.o" ]; then ./scripts/recordmcount  "/tmp/vbox.0/linux/SUPR0IdcClient-linux.o"; fi; fi;
  if [ "-pg" = "-pg" ]; then if [ /tmp/vbox.0/VBoxNetFlt.o != "scripts/mod/empty.o" ]; then ./scripts/recordmcount  "/tmp/vbox.0/VBoxNetFlt.o"; fi; fi;
/tmp/vbox.0/linux/VBoxNetFlt-linux.c: In function ‘vboxNetFltLinuxSkBufFromSG’:
/tmp/vbox.0/linux/VBoxNetFlt-linux.c:741:24: error: ‘SKB_GSO_UDP’ undeclared (first use in this function)
             fGsoType = SKB_GSO_UDP;
                        ^
/tmp/vbox.0/linux/VBoxNetFlt-linux.c:741:24: note: each undeclared identifier is reported only once for each function it appears in
In file included from /tmp/vbox.0/include/iprt/types.h:29:0,
                 from /tmp/vbox.0/r0drv/linux/the-linux-kernel.h:34,
                 from /tmp/vbox.0/linux/VBoxNetFlt-linux.c:24:
/tmp/vbox.0/linux/VBoxNetFlt-linux.c: In function ‘vboxNetFltLinuxCanForwardAsGso’:
/tmp/vbox.0/linux/VBoxNetFlt-linux.c:1276:53: error: ‘SKB_GSO_UDP’ undeclared (first use in this function)
     if (RT_UNLIKELY( skb_shinfo(pSkb)->gso_type & ~(SKB_GSO_UDP | SKB_GSO_DODGY | SKB_GSO_TCPV6 | SKB_GSO_TCPV4) ))
                                                     ^
/tmp/vbox.0/include/iprt/cdefs.h:1616:53: note: in definition of macro ‘RT_UNLIKELY’
 #  define RT_UNLIKELY(expr)     __builtin_expect(!!(expr), 0)
                                                     ^
/tmp/vbox.0/linux/VBoxNetFlt-linux.c: In function ‘vboxNetFltLinuxForwardToIntNetInner’:
/tmp/vbox.0/linux/VBoxNetFlt-linux.c:1526:47: error: ‘SKB_GSO_UDP’ undeclared (first use in this function)
         if (   (skb_shinfo(pBuf)->gso_type & (SKB_GSO_UDP | SKB_GSO_TCPV6 | SKB_GSO_TCPV4))
                                               ^
scripts/Makefile.build:311: recipe for target '/tmp/vbox.0/linux/VBoxNetFlt-linux.o' failed
make[2]: *** [/tmp/vbox.0/linux/VBoxNetFlt-linux.o] Error 1
Makefile:1498: recipe for target '_module_/tmp/vbox.0' failed
make[1]: *** [_module_/tmp/vbox.0] Error 2
/tmp/vbox.0/Makefile.include.footer:97: recipe for target 'vboxnetflt' failed

Foi algo relacionado com a variável SKB_GSO_UDP, que parece não existir no kernel mais recente ou no VirtualBox.

Buscando pelo termo pude encontrar que realmente existe uma diferença entre ambos um patch precisa ser aplicado, descrito aqui:

Fonte: https://gist.github.com/herbmillerjr/039c129e9c25b047b906e19ad1f23a59

diff --git a/work/vboxnetflt/linux/VBoxNetFlt-linux.c b/work/vboxnetflt/linux/VBoxNetFlt-linux.c
index f824654..b61d82c 100644
--- work/vboxnetflt/linux/VBoxNetFlt-linux.c
+++ work/vboxnetflt/linux/VBoxNetFlt-linux.c
@@ -126,6 +126,10 @@ typedef struct VBOXNETFLTNOTIFIER *PVBOXNETFLTNOTIFIER;
 # endif
 #endif

+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 14, 0)
+#define SKB_GSO_UDP 0
+#endif
+
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 20, 0)
 # define VBOX_HAVE_SKB_VLAN
 #else
diff --git a/work/vboxpci/linux/VBoxPci-linux.c b/work/vboxpci/linux/VBoxPci-linux.c
index 2dbf47f..e361ef3 100644
--- work/vboxpci/linux/VBoxPci-linux.c
+++ work/vboxpci/linux/VBoxPci-linux.c
@@ -353,12 +353,16 @@ static void  vboxPciFileClose(struct file* file)
 static int vboxPciFileWrite(struct file* file, unsigned long long offset, unsigned char* data, unsigned int size)
 {
     int          ret;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 14, 0)
+    ret = kernel_write(file, data, size, &offset);
+#else
     mm_segment_t fs_save;

     fs_save = get_fs();
     set_fs(get_ds());
     ret = vfs_write(file, data, size, &offset);
     set_fs(fs_save);
+#endif
     if (ret < 0)
         printk(KERN_DEBUG "vboxPciFileWrite: error %d\n", ret);

Mas como minha versão de VirtualBox não era exatamente a mesma que essa descrita, acabei fazendo o patch manualmente, que adiciona a variável SKB_GSO_UDP ao VirtualBox caso seja um kernel 4.14.0 ou superior.  Os arquivos para serem modificados no Ubuntu (e possivelmente Debian) são:

• /usr/share/virtualbox/src/vboxhost/vboxnetflt/linux/VBoxNetFlt-linux.c
• /usr/share/virtualbox/src/vboxhost/vboxpci/linux/VBoxPci-linux.c

depois basta rodar novamente como root o comando /sbin/vboxconfig para criar os módulos de kernel necessários pro funcionamento do VirtualBox.

SKB_GSO_UDP

SKB: SocKet Buffer

GSO: Generic Segmentation Offloading

UDP: User Datagram Protocol

Não tenho idéia do que isso faz exatamente mas parece ser uma chamada de um pacote UDP encapsulado.