segunda-feira, 26 de outubro de 2015

Compilando imagens do Debian Live com Bitbucket, SourceForge e Google Cloud



Recentemente, implantamos Linux em alguns dos computadores da empresa. Para esses usuários, que lidam a maior parte do tempo com o browser, a migração não foi problemática: não havia a necessidade de software específico para eles. Como utilizamos o Google Apps for Work, então não temos nenhum problema de compatibilidade, e podemos contar com backups, colaboração em tempo real, e portabilidade da informação.

Para facilitar a implantação, eu precisava de uma forma de fazer uma seleção de scripts, aplicar algumas customizações e configurações internas para aderir à nossas políticas de software, e foi aí que tive a idéia de criar uma imagem customizada do Debian.

Eu uso a nuvem do Google diariamente, seja em minhas atividades de trabalho ou seja em meus projetos pessoais. Neste post eu vou comentar como eu conectei diferentes serviços à nuvem do Google para viabilizar um desses projetos pessoais e sem fins lucrativos: o ronolinux.

Esse projeto nada mais é do que de uma compilação de imagens live, resultado de uma seleção minimalista de pacotes para facilitar a implantação do Linux em meus casos de uso. Ele também serve como um projeto modelo para quem deseja masterizar seu próprio DVD/USB-live com Debian personalizado.

Debian Live

O projeto que eu utilizei como base no ronolinux foi o Debian Live, agora Live Systems. Este projeto consiste em um conjunto de scripts para a configuração e compilação de imagens live baseadas no Debian e derivados. Este é o projeto que produz as imagens live oficiais do Debian, então tem suporte no repositório e é mantido por um desenvolvedor Debian.

Bom, mas o que tem o Debian Live a ver com a nuvem do Google? Eu tinha um pequeno problema com relação ao ronolinux. Compilar a imagem leva um tempo, requer uma boa conexão com a internet, um bom espaço em disco para cache. Fazer isso no notebook, via wifi, acabava por gerar alguns problemas:
  • Eu tinha que levar meus dados de um lugar para o outro, estava tudo no notebook.
  • Eu tinha que aguardar o build terminar localmente para então desligar o notebook. Isso era ruim, porque eu queria deixar ele rodando no final do dia, pra não adiar uma correção pro dia seguinte.
  • O build consome muita memória e CPU em alguns estágios, e eu não conseguia prosseguir com outras atividades na máquina que estava compilando a imagem.
  • Eu queria iterar no desenvolvimento em momentos nos quais eu não tinha a máquina de build em mãos, ou quando ela não estava ligada.
  • Para testar as imagens, eu tinha que ou copiar em mídia, ou fazer o upload de arquivos de alguns gigabytes.

Nuvem para o resgate!

Não só porque está na moda, no meu caso era a solução perfeita: rodar os builds na nuvem! Para isso eu fiz uma máquina virtual Debian Jessie no Compute Engine e começei a compilar as imagens por lá.

Com isso eu tinha diversas vantagens. Como eu poderia apenas abrir o browser e conectar por SSH na máquina virtual, não precisava mais carregar o notebook pra lá e pra cá. Além disso, eu podia também contar com algumas vantagens do Compute Engine, tais como uma boa conexão de rede para baixar pacotes, e o disco persistente para fazer cache entre uma compilação e otura, além de poder escolher diferentes opções de disco, CPU e memória.

O Compute Engine é tão bem integrado com o Debian que temos até um mirror do repositório acessível de dentro do Google Cloud, otimizando ainda mais o build. Mas eu não parei por aí. Afinal de contas, estamos na era da integração contínua, e compilar as imagens é feito a partir de um código-fonte simples que configura como e quais pacotes vão na ISO.

Push to deploy!

Eu queria implementar um recurso extra: fazer o build ser acionado por um push no repositório. Para isso, o que eu fiz foi implementar um handler HTTP  em Go, utilizando o pacote vmproxy, que eu desenvolvi para permitir executar VMs do Compute Engine a partir do App Engine, sob-demanda, bem como "desligá-las" quando não estão mais em uso.

Desta forma, não só eu pude configurar uma webhook no Bitbucket para automatizar o build, mas também publicar o resultado no SourceForge, que tem um bom espaço para armazenamento e uma integração por rsync para o upload, o que o tornou uma opção exclenente para hospedar o resultado das imagens.

O melhor disso tudo é que eu posso usar máquinas virtuais com disco SSD, bom desempenho de CPU e Memória, e ainda contar com uma redução fantástica de custos: posso usar uma máquina preemptível, que é muito mais barata do que a máquina virtual convencional!

Neste ponto você pergunta: - Mas você não está fazendo imagens live? O problema do upload de imagens ficou resolvido, mas e pra testar, não tem que baixar tudo de novo?

Exatamente! Para resolver isso, eu aprendi uma coisa ao trabalhar como Debian Live. Automaticamente, o sistema gera um arquivo .zsync. O zsync é uma ferramenta ideal para sincronizar arquivos, especialmente nesse caso que são arquivos ISO, alterados frequentemente. O zsync baixa o arquivo de controle, e depois só baixa os pedaços da imagem nova que você ainda não tem. Isso é ótimo, e eu pude comprovar: reaproveitei mais de 85% do arquivo de imagem entre um build e outro!

Meu workflow agora ficou assim:
  1. De qualquer lugar, posso fazer apenas um push para o Bitbucket com uma mudança de configuração: incluir pacote, adicionar hook, etc.
  2. O Bitbucket aciona meu webhook no App Engine, que liga a VM com o script de startup.
  3. O script faz o checkout do Bitbucket, compila as imagens, e publica no SourceForge. No final, desliga a VM e salva um backup dos logs no Cloud Storage.
  4. Eu configurei uma notificação no SourceForge, e sempre que ele recebe uma versão nova do ronolinux, eu recebo um email.
  5. Para testar, eu baixo a versão atualizada do meu ISO com o zsync, reaproveitando o máximo da imagem anterior que eu já tinha na máquina de testes, ou baixando uma nova, pra testar em qualquer lugar.

Conclusão

Utilizando recursos hoje já disponíveis, é possível elaborar mecanismos complexos para resolver problemas de forma simples e prática, e sem pagar muito por isso. O que eu vou ter de custos com o Google Cloud não compra um computador novo, que ainda me custaria energia pra rodar apenas esse projeto simples e sem fins lucrativos que é o ronolinux. Com a nuvem do Google e os serviços Bitbucket e SourceForge, eu pude conectar as peças e obter um workflow que otimiza o meu tempo e torna o build simples e rápido.

Estou agora considerando reduzir o tempo de 1h pra gerar as duas "edições" do ronolinux, desktop e developer, em paralelo, o que deve deixar tudo em torno de 30min depois do commit.

Você pode encontrar o código-fonte, incluindo os scripts de build do Compute Engine no meu projeto do Bitbucket. As imagens que estou produzindo ainda estão em fase prelimitar de testes, mas caso queira conferir estão aqui no SourceForge.

:happy hacking!


terça-feira, 1 de setembro de 2015

Olá, Gopher!


O Google desenvolveu uma nova linguagem de programação, chamada Go, que tem uma proposta moderna e inovadora. Go é uma linguagem compilada, estaticamente tipada, e que foi inicialmente projetada para ser um substitudo de C. Com uma sintaxe simples e concisa, recursos de programação concorrente avançados, e com uma runtime e garbage collector, Go possui recursos avançados de programação.

Neste artigo nós vamos dar os primeiros passos em Go, instalando o compilador em ambiente Linux e escrevendo nosso primeiro programa. Neste artigo vamos explorar também algumas das características do Go que o tornam atrativo para o programador de hoje em dia.

Obtendo o compilador Go

Como é uma linguagem compilada, você vai precisar de um compilador Go. Existem aqui duas opções: você pode utilizar o GCC, se já está acostumado, pois o gccgo já faz parte das edições mais recentes do compilador Gnu. Eu recomendo a segunda opção: utilizar a compilador e a coleção de ferramentas do próprio Go. Além de vários recursos extras, o compilador oficial recebe os recursos novos primeiro.

Para obter o compilador Go, faça o download no site oficial da linguagem em https://golang.org/dl/. No site você pode escolher a versão correta para seu sistema operacional e arquitetura, e então seguir as instruções para instalar em seu sistema Operacional. Em sistemas Linux, basta extrair o arquivo baixado (.tar.gz) em sua pasta /usr/local. Em seguida, você pode então configurar a variável PATH para incluir a pasta onde o Go foi instalado.

Se você utilizar Linux, e seu computador for de 64 bits, pode utilizar estes comandos:

$ curl https://storage.googleapis.com/golang/go1.5.linux-amd64.tar.gz | sudo tar -C /usr/local -xzf -
$ echo 'export PATH=$PATH:/usr/local/go/bin' >> .bashrc

Desta forma, basta você recarregar seu shell e confirmar que o Go está instalado:

$ go version
go version go1.5 linux/amd64


Agora vamos a uma etapa da isntalação que é importante. O Go assume que você vai guardar seus arquivos em uma pasta especial, chamada GOPATH. O compilador vai usar essa variável para encontrar seu código, bem como as dependências de terceiros que você utilizar. Imagine que isso é o equivalente à dezenas de milhares de -I e -L para compilar código C, ou configurar o CLASSPATH do compilador Java. Em Go, sempre preferimos convenção a configuração, e isso traz benefícios logo de início!

Escolha uma pasta onde você vai guardar seus projetos Go. Se estiver com dúvidas, você pode fazer a sua pasta principal ser a pasta do GOPATH:

$ echo 'export GOPATH=$HOME' >> .bashrc
$ echo 'export PATH=$PATH:$GOPATH/bin' >> .bashrc

Note que na segunda linha, eu adicionei mais um diretório ao PATH: o GOPATH/bin, que é onde o Go instala os programas. Isso faz com que logo depois de compilar e instalar localmente seus programas Go, eles já estão prontos para uso!

Seu primeiro programa Go

Agora que você já tem o comando go instalado, vamos usá-lo para criar nosso primeiro programa. O programa deve ser salvo na pasta src/hello de seu $GOPATH.

Vamos criar o arquivo hello.go com o seguinte conteúdo:

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello, world!")
}

Salve o arquivo e em seguida, execute o comando go build:

~/src/hello$ go build
~/src/hello$ ls
hello  hello.go


Agora vamos executar nosso programa:

~/src/hello$ ./hello
Hello, world!


Pronto! Você acaba de criar seu primeiro programa em Go. O comando go build executa o processo de compilar e linkar seu programa, ou seja, ele irá transformar seu código fonte em um arquivo binário executável, estaticamente linkado. Isso significa que você pode simplesmente copiá-lo e executá-lo em outro computador com a mesma arquitetura/sistema operacional, as biblitoecas, a Runtime do Go e o Garbage collector são todos inclusos em seu programa.

Neste artigo não vamos entrar em detalhes sobre a sintaxe, mas como você pode notar no exemplo acima, ela é simples e elegante, direto ao ponto. Eu vou começar aqui uma série de posts sobre como programar em Go, todos com a tag golang, então fique de olho!

Poste nos comentários o que gostaria de aprender sobre Go, ou se você já utiliza, compartlhe o que achou da linguagem!

Happy Hacking!

The Go Gopher is a creation of Renee French, under Creative Commons 3.0.

segunda-feira, 24 de agosto de 2015

Primeiros passos com o Raspberry Pi


O Raspberry Pi é um mini computador desenvolvido por pesquisadores da Universidade de Cambridge, com o objetivo de oferecer aos estudantes uma ferramenta de baixo custo, com o intuito de incentivar os estudos em programação de computadores. O Pi é um computador pessoal, como o que você compra em lojas, com alguns recursos limitados, tamanho reduzido e preço acessível: $35.

O Pi é um computador completo: processador, memória RAM, portas USB, saída de vídeo componente e HDMI, saída de áudio, plug RJ45 para rede cabeada (ethernet). O setup básico consiste em você plugá-lo em sua TV pelo HDMI ou vídeo componente (RCA), plugar na porta USB um teclado e ligá-lo. O Pi não possui um gabinete, mas existem cases para protegê-lo.

Propositalmente, ele possui alguns circuitos e pinos para conexão, os chamados GPIOs (General-pourpose Input/Output - entrada e saída de propósito geral), permitindo usar o Pi em projetos de eletrônica diversos, conectando-o a componentes customizados, proto-boards, sensores, e outros.

O primeiro passo é comprar um Pi. Se você estiver em uma viagem para os EUA (como foi o meu caso no Google I/O 2014), basta encomendar um pela Amazon. Se você não for viajar, pode também importar um dos resellers que possuem international shipping, mas leve em conta que o imposto a ser pago na alfândega é o de um computador. Aqui no Brasil você encontra ele a um preço um pouco mais salgado do que a proposta inglesa. O Pi deve sair em torno de R$ 120,00 a R$ 180,00, pesquise no Mercado Livre ou em lojas de eletrônica.

Existem duas gerações de raspberry Pi. Na primeira geração, temos dois modelos, o Pi 1 Model A+, Pi 1 Model B+. Recentemente foi lançada a segunda geração, o Pi 2 Model B+. O Model Pi 1 A+ possui o menor consumo de energia dos três, mas um baixo poder de processamento e memória RAM, e o Pi 2 Model B+ é o que possui mais recursos.

De posse do seu Pi, você primeiro deve instalar ou configurar o cartão de memória para boot com um sistema operacional. O Pi funciona geralmente com alguma versão do Linux, já que o kernel, módulos e o tamanho do sistema instalado podem ser otimizados para o hardware do Pi. No meu caso, eu comprei um Kit da Amazon, em uma viagem ao exterior, e o meu cartão de memória já veio formatado com o software para a instalação de diversos sabores de sistemas que funcionam no Pi. Ao ligar, o setup já lhe pergunta qual o sistema você quer instalar e faz o processo todo sozinho. Você também encontra tutoriais sobre como configurar o Raspbian, versão do Debian para o Raspberry Pi, ou até locais que vendem o Raspbian pré-instalado no SD-Card. Recomendo comprar o cartão já instalado se você quiser ir direto para a implementação de algo útil.

Com o cartão de memória configurado, basta plugar os componentes. Eu utilizei uma TV, com entrada HDMI, e um teclado USB sem fio da Logitec, que já vem com um Touch Pad (é, eu voltei dos EUA cheio de bugingangas...). O Pi, diferente de um computador convencional, não tem um botão liga/desliga: a fonte de alimentação já inicia o boot. Com ele ligado, basta seguir as orientações on-screen. Eu escolhi o Raspbian, a versão do Debian GNU/Linux compilada para o Pi. Eu gosto muito do Debian, já tenho vários anos de experiência e hoje ele está no meu computador de casa, trabalho e notebook. A instalação é bem simples a partir do SD card já formatado para o Pi, então basta esperar pela mensagem de que o SO foi instalado com sucesso.

Depois de instalado, o sistema faz o boot. É um boot de Linux tradicional: mensagens de log ao carregar os módulos do kernel e inicializar os serviços. O primeiro boot tem algumas opções de configuração inicial, como expandir o cartão de memória para ter espaço de armazenamento, alterar a senha do usuário padrão (recomendado!), entre outros. Você pode voltar nesta tela novamente mais tarde usando os seguintes comando:

sudo raspi-config

Eu utilizei as opções de atualização de senha e habilitar a câmera, já que eu também comprei o módulo de câmera compatível com o Pi, bem como a de configurar opções locais, e ajustei o fuso horário e relógio do Pi, mas mantive o idioma em inglês. Eu também entrei nas opções avançadas, para habilitar o SSH, assim eu poderia usá-lo sem um monitor, pela rede, bem como configurar o hostname, nome como ele é visível na rede.

Ao concluir as configurações do primeiro boot, eu recomendo reiniciar o Pi, quando ele lhe pergunta se você quer fazer isso, assim as suas configurações podem ser validadas logo no início. Minha recomendação é para que você já teste se os ajustes feitos entrão em efeito da forma correta.

Depois de reiniciar o Pi, ele está pronto para uso. Ao ligar o Pi, ele inicializará em modo texto, ou seja, você não vai ver uma tela gráfica logo de início. Ele vai mostrar um prompt pedindo o nome de usuário. O Raspbian já vem com um usuário pi e a senha que você configurou no primeiro boot. Depios de digitar o usuário e senha, você pode digirar o comando

startx

Para carregar a interface gráfica do sistema, que é o LXDE, já com vários softwares e configurações para o Pi disponíveis: o manual do Debian, IDLE, uma IDE para o Python, documentação sobre o desenvolvimento de jogos com PyGame, link para a loja do Pi, configuração de rede sem fio (se você tiver um wifi usb), e muito mais. Um item interessante é o Scratch, um aplicativo desenvolvido para o Pi, para ensinar programação para crianças. Você monta um algoritmo de forma visual, e executa ele no Scratch.

O que fazer com ele?

Por ser um computador completo, o céu é o limite! O seu tamanho pequeno e baixo consumo de energia proporcionam diversas aplicações onde um computador convencional não seria adequado. Eu já postei aqui no blog um tutorial de como usá-lo pra transformar uma impressora convencional em uma impressora do Cloud Printer (na verdade, uma impressora de rede local também, via Cups).

Eu tenho alguns projetos em mente para implementar, incluindo:
  • Um vídeo-game com motion detection para controles.
  • Um roteador customizado com modens.
  • Ser a central de controle de um sistema de automação/monitoramento residencial.
E você, o que gostaria de implementar com um Pi? Poste aqui nos comentários!

Happy hacking!

Referências

[1] Richardson, Matt, and Shawn P. Wallace. Getting started with Raspberry Pi. Sebastopol, CA: O'Reilly Media, 2012.
[2] Raspberry Pi Hardware - https://www.raspberrypi.org/documentation/hardware/raspberrypi/

sexta-feira, 12 de junho de 2015

Conectando sua impressora convencional ao Google Cloud Print com Raspberry PI e Debian

O Google Cloud Print é um serviço do Google que possibilita realizar impressão de documentos, fotos e outros tipos de arquivo utilizando a internet. Isso significa que você pode conectar suas impressoras em qualquer dispositivo compatível, como tablets e telefones, e realizar impressões diretamente deles. O mais bacana: é possível configurar tudo via software!

Neste post nós vamos aprender como configurar o Google Cloud Print no Linux, utilizando o Raspberry PI. O motivo de eu utilizar este equipamento é que ele pode ficar ligado o tempo todo, gastando bem menos energia do que um computador convencional. Além disso, o Pi pode ser usado para outras tarefas, como servir arquivos de mídia ou rodar alguns joguinhos, ou servir de equipamento de vigilância com câmera. Isso ficará para os próximos posts :)

Você vai precisar de:

  • Uma impressora
  • Um Raspberry PI (com Raspbian) ou um Computador (com Debian/Ubuntu)
  • Conhecimentos básicos de comandos do Linux
  • Uma conta do Google

Conecte o Pi à internet

Estou assumindo que você já possui o Pi funcional ou um computador com Linux. Eu recomendo usar no Pi o Raspbian e em um computador convencional o Debian.

O primeiro passo é ligar e acessar seu Raspberry, e conectá-lo com a sua rede de internet. Você pode ligar o Pi e conectar nele um teclado, e ligar ele na TV pela saída HDMI. Se você possui um Wifi USB, pode deixar a conexão sem fio, senão, pode conectá-lo via rede cabeada mesmo. Com ele na rede, você também pode usar um computador para conectar-se via SSH no Pi.

Importante: o seu Pi precisa estar conectado à internet, caso contrário o Cloud Print não vai funcionar.

Instale o software necessário

Importante: neste tutorial iremos executar diferentes comandos, como diferentes usuários: isso serve para garantir a adequada execução do Cloud Print Proxy. Eu vou assinalar os comandos a serem executados como o usuário padrão (geralmente pi) que possui o sudo habilitado, bem como os comandos que iremos executar com a conta dedicada ao Cloud Print (googlecloudprint). A parte em cinza serve apenas para isso, os comandos são apenas a parte em negrito.

Primeiro, faça um upgrade para obter as atualizações de segurança:

pi@pi$ sudo apt-get update && sudo apt-get upgrade

Em seguida, vamos instalar o Chromium, que é a versão do Google Chrome para o Debian, e o servidor de impressão chamado CUPS:

pi@pi$ sudo apt-get install chromium cups unzip
pi@pi$ sudo apt-get clean

Adicione sua Impressora ao Pi

Agora que temos o software necessário, vamos à configuração. Primeiro, vamos criar uma conta dedicada à impressão, chamaremos o usuário de googlecloudprint e vamos dar a ele acesso à gestão de impressoras, pelo grupo lpadmin.

Para isso, execute o comando abaixo e preencha os campos para criar o usuário. Você definirá um senha para este usuário que iremos precisar logo em seguida, tome nota da mesma e não deixe essa ser uma senha fraca.

pi@pi$ sudo adduser --ingroup lpadmin googlecloudprint

Agora, vamos configurar o CUPs para que possamos adicionar impressoras ao Pi, que serão depois configuradas como impressoras do Cloud Print. O CUPS possui uma interface web que permite gerenciar as impressoras, e nós vamos ativar esta interface web na rede local, assim podemos fazer a gestão das impressoras de outros computadores e o Pi não precisa ficar conectado a teclado ou monitor.

Para isso nós vamos editar o arquivo de configuração do CUPS que está na pasta /etc/cups:

pi@pi$ sudo nano /etc/cups/cupsd.conf

A primeira modificação é no parâmetro Listen, que está restrito ao próprio computador, e nós vamos modificar para não restringir apenas à maquina local. No arquivo, procure por:

# Only listen for connections from the local machine.
Listen localhost:631
Listen /var/run/cups/cups.sock

E modifique para:

# Only listen for connections from the local machine.
# Listen localhost:631
Listen /var/run/cups/cups.sock
Port 631

Agora, mais abaixo no mesmo arquivo, vamos ajustar as configurações de segurança. Procure pelas linhas abaixo, e inclua Allow @local, semelhante ao que está destacado em negrito:

< Location / >

# Restrict access to the server...
Order allow,deny
Allow @local
< /Location >

< Location /admin >
# Restrict access to the admin pages...
Order allow,deny
Allow @local
< /Location >

< Location /admin/conf >
AuthType Default
Require user @SYSTEM

# Restrict access to the configuration files...
Order allow,deny
Allow @local
< /Location >

Depois de salvar as alterações no arquivo (no nano, utilize CTRL+X depois Y ENTER), reinicie o CUPS:

pi@pi$ sudo service cups restart

Agora que está tudo configurado, tente acessar o CUPS pelo endereço IP do seu Raspberry, na porta 631, a partir de qualquer outro computador na rede ou mesmo de se seu smartphone, se ele estiver conectado à mesma rede que o Pi: https://ip-do-seu-raspberry:631/.  Dica: conecte-se via HTTPS, e confirme a exceção de segurança se o navegador exibir essa pergunta.

Uma vez conectado ao CUPS, clique em Administration:


E em seguida, no botão Add Printer:


O CUPS vai pedir uma usuário e senha. Informe o usuário e senha que criamos antereiormente: googlecloudprint. Escolha a impressora na lista. Você pode adicionar impressoras de rede que estiverem acessíveis ao Pi, ou a impressora conectada por USB. Em seguida, clique em Continue.

Informe um nome para sua impressora, sem espaços, informe uma descrição, que pode ter espaços, e uma localização, com "Casa" ou "Escritório". Clique em ContinueDica: ao marcar Share this printer, sua impressora ficará visível para outros computadores da rede local, assim você poderá utilizá-la como impressora de rede, mesmo sem o Cloud Print.

Escolha o modelo, normalmente ele estará pré-selecionado, dê um nome para ela e em seguida clique em Add Printer.

Pode ser que o CUPS exiba também uma página para configurar alguns valores padrão, como orientação de papel, etc. Faça as escolhas que julgar necessário e clique em Set Default Options.

Eu sugiro que você imprima uma página de testes via CUPS, só para ter certeza que está tudo OK e que o Pi consegue enviar a impressão corretamente.

Configure o serviço do Google Cloud Print

Agora, para por nossa impressora na núvem, vamos utilizar o Chromium. As etapas para configurar o Cloud Print em modo servidor podem ser obtidas na documentação oficial, mas eu traduzi e adicionei algumas etapas para a configuração ficar mais robusta.

Primeiro, vamos trocar de usuário para o que criamos anteriormente. Observe que no seu shell, o nome do usuário vai mudar de pi para googlecloudprint:

pi@pi$ sudo su googlecloudprint
googlecloudprint@pi$ cd ~/

Agora, faça o download do arquivo generate_cloudprint_config.py.zip:

googlecloudprint@pi$ wget http://www.google.com/support/enterprise/static/chromeos/docs/admin/en/generate_cloudprint_config.py.zip
googlecloudprint@pi$ unzip generate_cloudprint_config.py.zip
googlecloudprint@pi$ chmod +x generate_cloudprint_config.py

Agora, para concluir, nós vamos utilizar este script para configurar nossa conta do Google para nosso servidor de impressão:

googlecloudprint@pi$ ./generate_cloudprint_config.py

Dica: se você utiliza Two Factor Authentication, vai ter que definir uma Senha de Aplicativo para utilizar. Não se engane: ao por a sua senha do Google o script acima termina sem erros, mas não gera tokens de acesso.

Siga os passos apresentados pelo script. Informe seu usuário e senha do Google, ou senha de aplicativo se tiver two factor authentication ativo. A sua saída será algo mais ou menos assim:

Email Address: ******@gmail.com
Password for ******@gmail.com
Connector Id: raspberrypi
Printserver URL with port (keep empty to skip): http://localhost:631/
Config file raspberrypi.conf generated for proxy raspberrypi

É importante que você informe o nome do conector raspberrypi e a URL do servidor de impressão CUPS na configuração. Depois que o comando terminar, você terá um arquivo chamado raspberrypi.conf, que deve ser renomeado para Service State:

googlecloudprint@pi$ mv raspberrypi.conf 'Service State'

Agora, vamos criar um script de configuração para o serviço iniciar automaticamente quando ligarmos o Pi.

Dica: Você pode usar o comando: googlecloudprint@pi$  cat > google-cloud-print  e em seguida colar o conteúdo e pressionar CTRL+D para salvar. 

Salve o arquivo abaixo com o nome google-cloud-print na pasta /home/googlecloudprint:

#!/bin/bash

### BEGIN INIT INFO
# Provides:          google-cloud-print
# Required-Start:    $remote_fs $syslog $networking
# Required-Stop:     $remote_fs $syslog $networking
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Google Cloud Print Service
# Description:       This service launches a Google Cloud Print.
### END INIT INFO

export HOME="/home/googlecloudprint/"
unset DISPLAY

start_service() {
        echo "Starting service ..."
        cd $HOME
        start-stop-daemon --start \
                --chuid googlecloudprint \
                --chdir /home/googlecloudprint \
                --background --verbose \
                -x /usr/lib/chromium/chromium -- \
                        --type=service \
                        --enable-cloud-print-proxy \
                        --no-service-autorun \
                        --noerrdialogs \
                        --user-data-dir=/home/googlecloudprint/ \
                        --enable-logging --v=1
}

find_pid() {
        ps fax | grep enable-cloud-print-proxy |\
                grep -v grep | awk '{print $1}'
}

stop_service() {
        echo "Stopping service ..."
        PID="$(find_pid)"
        case "$PID" in
                [0-9]*)
                        echo "Killing $PID ..."
                        kill -9 $PID 2>/dev/null
                ;;
                *)
                        echo "Not running ..."
                ;;
        esac
}

case $1 in
        start)
                start_service
        ;;
        stop)
                stop_service
        ;;
        restart)
                stop_service
                start_service
        ;;
esac

Agora, vamos instalar este script que criamos como um serviço no sistema:

googlecloudprint@pi$ chmod +x google-cloud-print
googlecloudprint@pi$ exit #para retornar ao usuário que possui acesso sudo (pi no meu caso)
pi@pi$ sudo ln -s /home/googlecloudprint/google-cloud-print /etc/init.d/google-cloud-print
pi@pi$ sudo update-rc.d google-cloud-print defaults
pi@pi$ sudo service google-cloud-print start

Agora, navegue até a página do Google Cloud Print e confirme se a impressora está disponível e online:


Veja nos detalhes avançados da impressora, e note que o campo Proxy será o mesmo nome que definimos em nossa configuração.

Prontinho, agora você pode enviar trabalhos de impressão a partir de qualquer programa ou equipamento compatível com o Google Cloud Print, e eles são encaminhados à sua impressora via internet.

Happy hacking!