Fontes de aplicativos em GTK no KDE
Se existe algo que é um inferno em Linux é fonte. Como uso KDE como desktop padrão com HiDPI em 196 pontos, os aplicativos em GTK teimam em usar outras fontes e com tamanhos diferentes. É tipo uma maldição de Montezuma. Um dia seu ambiente gráfico está tudo certo, e de repente fica tudo com cara de que você tem problemas de visão.
E pior que os aplicativos escritos em GTK não respeitam o tamanho de fonte colocado no KDE. Uma das maneiras que encontrei foi usando comandos diretamente vi gsettings pra verificar o que os aplicativos em GTK têm configurados:
helio@xps13:~$ gsettings get org.gnome.desktop.interface text-scaling-factor helio@xps13:~$ gsettings get org.gnome.desktop.interface monospace-font-name helio@xps13:~$ gsettings get org.gnome.desktop.interface document-font-name helio@xps13:~$ gsettings get org.gnome.desktop.interface font-name helio@xps13:~$ gsettings get org.gnome.desktop.wm.preferences titlebar-font
e depois trocar pra padrões mais confortáveis.
helio@xps13:~$ gsettings set org.gnome.desktop.interface text-scaling-factor 0.5 helio@xps13:~$ gsettings set org.gnome.desktop.interface monospace-font-name 'Ubuntu Mono 10' helio@xps13:~$ gsettings set org.gnome.desktop.interface document-font-name 'Ubuntu 10' helio@xps13:~$ gsettings set org.gnome.desktop.interface font-name 'Ubuntu 10' helio@xps13:~$ gsettings set org.gnome.desktop.wm.preferences titlebar-font 'Ubuntu Bold 10'
E às vezes ainda preciso forçar um re-cache das fontes usadas com o comando:
helio@xps13:~$ sudo fc-cache -f -v
mas o resultado final é satisfatório (em geral basta fechar e abrir os programas pra encontrar a interface com as fontes corrigidas).
Bloqueando Youtube no OpenWRT
Quem tem filho sabe que não é fácil impor limites. Especialmente quanto uso de tablets ou smartphones ou até mesmo da TV. Eu tenho em casa um problema com YouTube que acaba virando a atração principal com um conteúdo bem longe de ser didático. Tentei até onde podia limitar no "YouTube é das 18 às 20" mas tenho fracassado miseravelmente.
Então resolvi apelar aos meus conhecimento computacionais e ao roteador por onde passa todo o tráfego da casa, e que roda open-wrt.
Criei um sistema básico em shell script que bloqueia tudo que é relacionado com YouTube em horários pré-determinados. Não ficou bonito, mas funciona.
#! /bin/sh
# save it into /usr/lib/scripts/firewall.sh
# and add into scheduled tasks as
# */5 * * * * /usr/lib/scripts/firewall.sh
hour=`date +%H`
minute=`date +%M`
echo "hour=$hour"
echo "minute=$minute"
status_file=/tmp/firewall_status
blocked_pattern="youtubei.googleapis.com googlevideo.com ytimg-edge-static.l.google.com i.ytimg.com youtube-ui.l.google.com www.youtube.com googleapis.l.google.com youtubei.googleapis.com video-stats.l.google.com ytimg-edge-static.l.google.com"
enable_firewall() {
echo "Enabling firewall"
for chain in INPUT FORWARD OUTPUT
do
count=1
for proto in tcp udp
do
for blocked in $blocked_pattern
do
echo iptables -I $chain $count -p $proto -m string --algo bm --string "$blocked" -j DROP
iptables -I $chain $count -p $proto -m string --algo bm --string "$blocked" -j DROP
count=`expr $count + 1`
done
done
echo iptables -I $chain $count -p udp --sport 443 -j DROP
iptables -I $chain $count -p udp --sport 443 -j DROP
count=`expr $count + 1`
echo iptables -I $chain $count -p udp --dport 443 -j DROP
iptables -I $chain $count -p udp --dport 443 -j DROP
count=`expr $count + 1`
done
}
disable_firewall() {
echo "Disabling firewall"
for chain in INPUT FORWARD OUTPUT
do
for proto in tcp udp
do
for blocked in $blocked_pattern
do
echo iptables -D $chain -p $proto -m string --algo bm --string "$blocked" -j DROP
iptables -D $chain -p $proto -m string --algo bm --string "$blocked" -j DROP
done
done
echo iptables -D $chain -p udp --sport 443 -j DROP
iptables -D $chain -p udp --sport 443 -j DROP
echo iptables -D $chain -p udp --dport 443 -j DROP
iptables -D $chain -p udp --dport 443 -j DROP
done
}
case $1 in
start) enable_firewall
echo -n "enabled" > $status_file
exit 0;;
stop) disable_firewall
echo -n "disabled" > $status_file
exit 0;;
esac
# possible status
# enabled|disabled
# start
# from 7:55-09:59
time_status=disabled
if [[ $hour -ge 7 && $hour -lt 10 ]]; then
time_status=enabled
if [[ $hour -eq 7 ]]; then
if [[ $minute -lt 55 ]]; then
time_status=disabled
else
time_status=enabled
fi
fi
fi
# from 12:00-17:59
if [[ $hour -ge 12 && $hour -lt 18 ]]; then
time_status=enabled
fi
# from 20:00-21:59
if [[ $hour -ge 20 && $hour -lt 22 ]]; then
time_status=enabled
fi
echo "time_status=$time_status"
current_status=
if [[ -f "$status_file" ]]; then
current_status=`cat $status_file`
fi
if [[ $current_status = $time_status ]]; then
echo "nothing to do"
else
if [[ $time_status = "enabled" ]];then
echo "loading firewall rules"
enable_firewall
fi
if [[ $time_status = "disabled" ]];then
echo "removing firewall rules"
disable_firewall
fi
echo -n $time_status > $status_file
fi
Basta salvar o arquivo em /usr/lib/scripts/firewall.sh e adicionar à crontab do open-wrt.
O código fonte está também publicado no github: https://github.com/helioloureiro/homemadescripts/blob/master/openwrt-firewall-block-youtube.sh
Feliz aniversário Debian! 25 anos!
25 anos de alegrias e tristezas. Felizmente mais alegrias :)
Desses 25 anos, estamos juntos 20 anos. Acho. Talvez mais.
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.