Os artigos mais lidos

Quarta, Janeiro 30, 2013 Helio Loureiro Blog 19953
XGH é uma das coisas mais genias que surgiu nos últimos tempos, descrevendo a estupidez que se aplica em métodos ágeis, mas que reflete bem o ambiente corporativo. Infelizmente o site foi abandonado...
Sábado, Maio 03, 2008 Helio Loureiro FreeBSD 17356
This article is kindly linked by: http://tuxmobil.org/hp_compaq.html http://tuxmobil.org/mobile_bsd.html Barely finished my last article about FreeBSD (PRERELEASE at that time) on Compaq laptops,...
Quarta, Junho 11, 2014 Helio Loureiro Blog 16669
Nem só de discussões de licença, flamewares, releases de kernel e ativistas sapatênis vive o mundo do software livre. Às vezes é envolto de mistério também. Um dos enigmas recentes foi o sumiço da...
Sexta, Maio 20, 2005 Helio Loureiro Python 15873
Esse é o script usado para autenticar automaticamente no Speedy da Telefonica (região de São Paulo). Evita que usuários residenciais, como eu, precisem estar em frente à máquina, permitindo que a...

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