domingo, 27 de janeiro de 2019

Publicando um aplicativo pelo gitlab

Como publicar uma branch do git, no gitlab usando o gitlab, Ingress e criando um apontamento DNS para um domino?

No artigo anterior apresentei o passo a passo que utilize para montar um pipeline completo no gitlab, criar uma instancia  de um container da imagem do meu aplicativo e colocar essa instancia em um cluster kubernetes usando google cloud. Para tornar acessivel o aplicativo, utilizamos um wildcard dns para responder para um IP através de um domínio não existente.

Link para o artigo: https://www.rcelebrone.com/2019/01/ci-cd-gitlab-google-cloud-kubernetes.html

Mas e se eu desejar publicar automaticamente em um domínio existente?

É perfeitamente simples e possível.
No artigo anterior, dentro do gitlab. Entre no projeto, em configurações, CI/CD e abra as configurações do recurso Auto DevOps. No campo domínio, no artigo anterior, utilizamos um serviço de wildcard DNS (o xip.io), para apontar para o IP do Ingress. É nesse campo domínio que temos que informar o domínio oficial por onde queremos servir nosso aplicativo.

* No gitlab, o IP do Ingress (caso tenha seguido o artigo anterior), está disponível dentro do projeto em Operações > Kubernetes > (clique no nome do cluster na lista) > O ip estará visível em aplicações > Ingress.


IP em mãos e domínio configurado no gitlab e agora?

Aqui tem uma observação. Existem diversas ferramentas de registro de domínio. No meu caso, trabalho com o uolhosts e diretamente no painel do uolhosts eu consigo fazer o apontamento que preciso. Para isso, basta criar no domínio um apontamento A Name para o endereço gerado pelo gitlab e o IP do Ingress.

Vale lembrar que por padrão (quando não definimos um arquivo gitlab-ci.yml), o gitlab utiliza uma junção do nome do seu grupo no gitlab com o nome do seu projeto. Então, por exemplo, se nossas informações são as seguintes:

  • Grupo do gitlab: universo
  • Nome do projeto: admin-jupiter
  • Ip do Ingress: 35.234.567.67
  • Domínio: nasa.com
Teremos o seguinte:

No serviço de configuração do domínio:
Crie um registro "A NAME" > com IP: 35.234.567.67 e endereço: universo-admin-juniper.nasa.com

No campo domínio do Ingress no gitlab:
Informe o domínio: nasa.com


* Para utilizar um endereço customizado, basta utilizar nas variáveis de ambiente: Dentro do projeto > Configurações > CI/CD > variáveis de ambiente. Então basta utilizar a variável: CI_PROJECT_PATH_SLUG e o nome do subdomínio. Ou seja, para o endereço xpto.exemplo.com, o valor dessa variável será xpto.

sexta-feira, 25 de janeiro de 2019

Integração e Entrega continua com gitlab, google cloud, kubernetes e café

Como criar um processo de teste, integração e deploy continuo usando o fantástico recurso de Auto DevOps do GitLab?

Hoje muito se fala em DevOps. Mas o que é DevOps?
DevOps é a junção das palavras "desenvolvimento" e "operação". Uma proposta que tomou força por diversos fatores. No lado técnico, as complexidades em entregar um software de forma ágil dependendo de outro time, ou talvez uma motivação natural pela gama de ferramentas e a tão difundida computação na nuvem, ou mesmo (para os que gostam de conspiração), uma força do mundo corporativo para reduzir os gastos com profissionais de TI centralizando os esforços em um mesmo time. Enfim, isso é meio que como aquela história do quem nasceu primeiro...

Fato que é DevOps está longe de ser uma novidade. Já amplamente praticado, principalmente por Startups que podem se dar ao luxo de criar seu software escolhendo entre centenas de softwares e hardwares gratuitos ou muito acessíveis e colocar seu negócio em produção quase que instantaneamente.

Falou, falou, falou e não disse nada!

É verdade! rsrs

Nos últimos dias estive avaliando uma serie de ferramentas e oportunidades de integração entre elas. Focando em 3 coisas: praticidade, custo e integração entre elas. Brinquei com bitbucket, github, docker hub, gitlab, docker registry, aws, jira, tfs, google cloud, jenkins, tfs e muitas outras. Meu objetivo era elencar ferramentas para montar um pipeline com no minimo teste automatizado, build, deploy e integração com uma ferramenta de projetos. Depois de muito teste e avaliação das ferramentas, cheguei a conclusão que o mais pratico, melhor custo beneficio e com ótimo custo seria trabalhar com gitlab integrado ao jira, utilizando o pipeline do próprio gitlab para o build e testes, bem como o container registry dele para armazenar as imagens e para o deploy uma integração bem bacana que o gitlab oferece dentro da ferramenta deles. O Gitlab Auto DevOps trabalha preferencialmente com Kubernetes no Google Cloud. Então, isso nos permite criar um pipeline completo sem muito trabalho. Abaixo vou descrever os passos de cada ferramenta e algumas observações que ninguém nos conta e acabamos por descobrir depois de apanhar um pouco.

Instalações. Não!

Tem um custo que não levamos em consideração, que é o custo para manter hardware e software. Então, resolvi me dar ao luxo de usar tudo na nuvem.

Então, vamos aos cadastros

  • Crie uma conta no http://gitlab.com
    • Crie um grupo (isso vai evitar que você tenha que configurar cluster kubernetes por projeto)
      • No menu superior "Grupos"
    • Crie um projeto (aqui não vou sugerir que usem algum pronto pois foi o que mais vi nos tutorias e quando montamos o nosso, não funciona)
      • Crie o projeto dentro do Grupo que você criou.
    • Clone o repositório do projeto criado na sua maquina, crie uma aplicação simples que possa ser compilada e em seguida, crie um Dockerfile para esse projeto. Única observação é que exporte a porta 5000 (vi isso em uma das documentações do Auto DevOps e no meu caso só funcionou quando usei a porta 5000)
      • Seria bacana criar também um teste dentro do projeto
  • Crie uma conta no http://cloud.google.com
    • Crie uma conta de pagamento na Google Cloud
    • Crie um projeto na Google Cloud
      • Acessando http://console.cloud.google.com na parte superior esquerdo da tela existe o menu pra criar projeto.
      • Na tela de criação do projeto basta informar o nome do projeto e selecionar a conta de pagamento (é necessário para o kubernetes engine api).
    • Projeto criado, clique no menu hamburger (superior esquerdo) e clique em APIs e serviços.
      • No painel, busque por Kubernetes Engine Api, clique e ative essa api no projeto

Vamos falar de coisa boa, vamos falar de gitlab

  • Novamente no gitlab, vá no menu grupos e clique no grupo que você criou.
  • Você perceberá que existe um menu Kubernetes. 
    • Clique nesse menu e na pagina que abrir, você deve utilizar a opção de criar Cluster Kubernetes no Google Cloud (clique no botão para autenticar pelo google). 
    • Preencha um nome para o cluster (como é o cluster onde estamos liberando produção, pode chamar o cluster de produção).
    • Escolha o projeto que você criou lá no Google Cloud no combo abaixo. 
  • Feito isso, clique em criar Cluster.
  • Aguarde criar completamente o cluster no Google Cloud e todas as instancias estarem executando.
    • Você pode acompanhar a criação lá no Google Cloud, novamente pelo menu hamburger, clicando agora na opção Kubernetes Engine > Clusters.
  • Assim que concluir a criação do cluster, no gitlab, ainda dentro de grupos > (seu grupo) > Kubernetes.
    • Instale o Helm Tiller e aguarde concluir a instalação.
    • Em seguida instale o Ingress e aguarde concluir a instalação e principalmente aparecer o IP no campo do Ingress (isso é importante).
  • Copie o IP do Ingress e entre no projeto que você criou no gitlab (o repositório).
    • Vá em configurações > CI/CD > Auto DevOps
    • Se não estiver ativo, ative a opção para tornar padrão o Auto DevOps
    • E no campo Dominio, cole o IP e concatene com xip.io
      • Fica algo assim: 35.123.654.23.xip.io
  • Clique em salvar alterações
Você poderá acompanhar as execuções das pipelines do gitlab acessando o seu grupo > o repositório > clicando no menu CI/CD > pipelines.

E que bruxaria é essa ai? 

O teste que você incluiu no projeto vai rodar, a aplicação vai compilar passando pelo build, qualidade de código também executa no projeto. "Production" faz toda a comunicação com o kubernetes subindo seu container a partir do registry.gitlab.com (um registry do gitlab que guarda as suas imagens, melhor do que pagar pelo docker hub e ainda não precisa se preocupar com integração) e por última, assim que a aplicação já está disponível. Acontece um teste de performance, que pelo log parece ser um crawler usando selenium para testar a velocidade da aplicação.

Simples não? 

Sim, é! Porém, tem muito material desatualizado que acaba complicando chegar nesses passos. Algumas coisas chatas ocorrem se seguirmos passos em outra ordem. Por exemplo não incluir o Kubernetes Engine Api no projeto do Google Cloud e tentar integrar no gitlab. De problema, ai você tem que atualizar a pagina da integração do gitlab e reiniciar o preenchimento. Ou o fato do Wildcard DNS não estar tão claro que deve ser usado a partir do IP do Ingress (eu usei o xip.io, mas tem outros, como o nip.io, por exemplo).

Enfim, é isso. Espero que ajude. 
Caso esteja implementando e usando essas mesmas ferramentas e algo der errado, entre em contato ou posta no stackoverflow e coloca o link nos comentários.


Ah, quase esqueci! 

É bem simples integrar o Jira, dentro do repositório no gitlab, vá em configurações > integrações > jira. E sobre o café no titulo desse post. Acredite, foram muitos cafés até chegar nesse resultado.

domingo, 9 de dezembro de 2018

Forma simples de criar e rodar uma aplicação react native no celular

Como criar uma aplicação react native e rodar em um aparelho android?


- Primeiro, execute no terminal o comando: 

lsusb

- Deve aparecer uma lista mais ou menos assim:

Bus 002 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub 
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub 
Bus 001 Device 003: ID 22b8:2e76 Motorola PCS 
Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub 
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub 
Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub

Na lista acima, identifique o ID correspondente ao seu aparelho e execute o comando abaixo com o ID identificado acima:

echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", MODE="0666", GROUP="plugdev"' | sudo tee /etc/udev/rules.d/51-android-usb.rules
*Isso permite incluir seu aparelho na lista de dispositivos disponiveis para debug

- E então, escolha onde quer criar seu projeto e crie o projeto base com o comando: 

react-native init AppTeste

- Entre na pasta do projeto criado:

cd AppTeste

-Execute o comando abaixo (com o aparelho ja conectado em modo debug):

react-native run-android

domingo, 25 de novembro de 2018

vscode salvar arquivo ou pasta como administrador

Como alterar um arquivo sem ter que usar privilegios de administrador no linux?

Bom, antes de mais nada tenho algo a dizer: Esse artigo não é um artigo oO? Isso mesmo, é mais uma dica para resolver de uma forma decente algo que é um pouco chato enquanto desenvolvemos no linux.

Ok, e?

Ocorre que quando criamos nossos projetos, dependendo de onde e como criamos nosso workspace, acabamos por ter um diretório onde o dono é o root e tudo que criamos dentro dele, acaba herdando a propriedade, grupo e permissões. E nós percebemos isso quando vamos alterar um arquivo e uma IDE ou editor de texto não altera a menos que executemos a ação de salvar como super usuário.

Para evitar problema com seus projetos (caso isso ocorra com você), faremos:

- Primeiro crie ou localize via terminal a pasta onde pretende colocar todos seus projetos (geralmente chamamos de workspace): Eu gosto de criar no /home/<USER>/workspace
- Pasta workspace criada, no terminal teremos: <USER>@<USER>: ~/workspace$
- Caso a pasta workspace já exista e tenha conteúdo, verifique quem é o dono usando: ls -al
- E para alterar para seu usuário, faça execute o comando na /home/<USER>sudo chown <USER>:<USER> -R workspace/

Dessa forma você garante que os projetos atuais e os próximos criados dentro de workspace, não lhe trarão problemas de permissão, pois são do próprio usuário que está editando.

Aeeeeee :D chuva de CTRL + S no vscode

terça-feira, 20 de novembro de 2018

Emulador do android e variáveis de ambiente no linux

Como configurar o emulador do android e as variáveis de ambiente necessárias?


Feriado rolando e o que fazer com esse belo dia? Um curso de react native, claro!
Na verdade comprei o curso para incentivar minha esposa a estudar desenvolvimento mobile e tudo estava muito bem até o primeiro erro acontecer :'(

Bom, não é de hoje que problemas de configuração de ambiente são comuns (e o linux é um pouco mais chato quando tratamos de configurações e para quem está iniciando -depois de um tempo vc aprende a amar S2-). Só pra esclarecer, erros de ambiente são normais, em qualquer plataforma e com tempo e experiência você acaba resolvendo essas coisas naturalmente, sem ser massacrado (mas no início, sim, vc vai tomar uma bela surra de configurações, erros de ambiente, vai descobrir que existe o stackoverflow e sua vida vai mudar). Enfim, chega de bla bla bla e vamos para o problema... ahmm?? oO

Para, para, para, para...

Antes, apenas para contextualizar. O curso que comprei e incentivei minha esposa estudar é o curso de React Native do Professor Leonardo Moura Leitão - https://www.udemy.com/curso-react-native/ - (que pra mim, é o melhor instrutor do Udemy -não conheço o cara e nem tem relação com o cargo dele, só gosto das aulas dele mesmo hehe).

Enfim, o problema (ou, os problemas)

Já na seção 2 do curso, o erro a seguir ocorreu no terminal: ERROR: x86 emulation currently requires hardware acceleration! Esse erro ocorreu por falta de permissão para o usuário atual no grupo /dev/kvm. Mas antes de chegar nesse problema, por algum motivo eu fui verificar as variáveis de ambiente e após fechar o terminal e abrir novamente, constatei que elas não estavam mais no PATH.

Certo, então como configurar as variáveis de ambiente no linux para ficarem definitivamente no path?

Bom, pelo terminal, com seu usuário, usando o export NOME_VARIAVEL="valor", funciona para a sessão atual, mas e se eu quero que esses valores fiquem permanentemente no meu PATH (e eu quero). Então preciso dos passos vem a seguir:

- sudo vim ~/.profile
no fim do arquivo (e já estou contando que nesse momento o android studio já está instalado), adicionamos as linhas:
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
export ANDROID_HOME=$HOME/Android/Sdk
export PATH=$PATH:$ANDROID_HOME/emulator
export PATH=$PATH:$ANDROID_HOME/tools
export PATH=$PATH:$ANDROID_HOME/tools/bin
export PATH=$PATH:$ANDROID_HOME/platform-tools
(dica: i para modo de inserção, depois de editar pressione esc e digite :wq para sair e salvar)
- source ~/.profile

Feito isso, basta fechar o terminal e agora estará disponível sempre que você abrir o terminal.

Certo, variáveis configuradas, mas ainda temos o problema de permissão no grupo /dev/kvm

Para resolver isso, vamos seguir os passos abaixo no terminal:
- sudo apt install qemu-kvm
- sudo adduser <seu usuário do sistema> kvm
- reinicie o computador (sim!)

Alguns fóruns recomendam que você use o próximo comando:
- sudo chown <seu usuário do sistema> /dev/kvm

*Não faça isso. Isso vai resolver sem reiniciar pois estará trocando a propriedade do grupo para o seu usuário. Mas tem cara de gambiarra. Apenas reinicie o computador e seu usuário estará no grupo.

Agora o emulador do android já deve executar perfeitamente. Teste via terminal:
- emulator -list-avds
(copie o nome se aparecer um nome - se não aparecer você terá de configurar uma avd e isso é mais simples pelo android studio)
- emulator -no-snapshot -avd <nome copiado>

E... tá lá :D



Flwss, espero ter ajudado. :P


Referências:
https://stackoverflow.com/questions/37300811/android-studio-dev-kvm-device-permission-denied
https://sempreupdate.com.br/como-configurar-uma-variavel-no-path-do-gnulinux/

quinta-feira, 4 de outubro de 2018

Quadro você programador no programa Inova 360

Eu estive no quadro você programador no programa Inova 360 da Record News

Dia 30 de setembro foi ao ar mais uma edição do quadro você programador no programa Inova 360 da Record News. O quadro é um espaço que trata assuntos relacionados a área de tecnologia da informação e os convidados contam um pouco da própria experiência na área.

O quadro




O programa completo (23:05 min)




Então se você é ligado em tecnologia, inovação, gestão e startup. Você certamente vai gostar do conteúdo do programa. Clique aqui e confira o canal do Inova 360.

domingo, 23 de setembro de 2018

Linguagem de programação Rust

Rust, uma linguagem rápida e segura?

Ontem, dia 22 de setembro, aconteceu a 3ª edição do #abcdev (confirma detalhes do que rolou nesse link) e eu estava lá. O evento aconteceu em São Caetano no Auditório do Centro de tecnologia Leandro Klein e foi patrocinado por algumas gigantes como redhat, via varejo, nubank e outras.

Ah, Fui um dos primeiros a chegar :). E quando digo que fui um dos primeiro, eu fui exatamente o segundo. Na minha frente estava um colega (não tem nada a ver com pontualidade, só nos confundimos e chegamos uma hora antes :P rsrs).

O evento teve uma série de palestras e em uma delas, apresentada pelo Bruno Rocha da redhat, me foi apresentado o Rust. Uma linguagem de programação que se define como sendo uma linguagem de programação de sistemas que opera de maneira incrivelmente rápida, evita os defeitos e garante a segurança da thread. É importante mencionar que não fiquei nessa palestra por estar empolgado com Rust. Eu nem mesmo sabia que existia Rust. Porém, no momento em que o Bruno disse que ela é uma linguagem que se propõe a ser mais rápida que C e C++, eu imediatamente ofereci uma overdose de atenção a cada palavra daquele momento em diante.

O Bruno mencionou muitos detalhes sobre a segurança da linguagem, o fato do compilador evitar que você escreva um código fraco que leve a erro de runtime. A performance dela superar a performance de linguagens como C e C++ e a sintaxe ser um tanto quanto agradável (considerando a categoría em que ela se posiciona).

Beber cerveja e assistir meu time jogar ou programar em uma nova linguagem?

Pff, não tem nem o que se discutir né?; claro que escolhi programar! Obviamente fiquei curioso e não conseguiria terminar o final de semana sem brincar com Rust e compartilhar um pouco do que fiz.

Maravilha, show me the code!

Não!, Antes de olhar qualquer código, faça exatamente o que eu não fiz (seguir a recomendação do Bruno Rocha na instalação).
Instale seguindo os passos abaixo (e recomendo fazer isso para que você não saia digitando código, queira compilar e acabe por instalar parcialmente seu ambiente e depois tenha que desinstalar tudo para conseguir fazer direito).

- Certifique-se de ter o curl instalado
- Via terminal, execute: curl https://sh.rustup.rs -sSf | sh

Agora, vamos para a IDE

Eu não segui nenhuma recomendação do rust-lang.org, e tão pouco do Bruno. Fui direto pra minha IDE favorita e certamente encontrei um plugin. Ou seja, abri o visual studio code e busquei por Rust.

Tudo configurado, hora de "codar"

A primeira coisa que fiz foi exatamente a primeira coisa que devemos fazer. Isso mesmo, um Hello World. E curti muito o println!("{0} {1}", ..., ...);

E então pensei, o que fazer para usar alguns recursos a mais?

Resolvi escrever um programa para consultar uma lista de nomes da esquerda para direita, ignorando o case. E acredite, é um saco trabalhar com string no Rust. Mas, gostei mesmo assim, poderia ser pior (se fosse em C, por exemplo). Se liga no resultado:

- Primeiro criei meu arquivo main.rs (pode ser qualquer nome, mas a convenção do rust sugere que você use hífen como separador no nome dos arquivos caso tenha dois nomes .rs, por exemplo batata-quente.rs).
- Depois criei o ponto de início de qualquer programa Rust (o método main).
- E escrevi o código abaixo:


fn main(){
println!("{0}, {1}. {2}", "Olá",
"Esse é meu primeiro programa Rust (depois do hello world!)",
"\nAbaixo vou listar os nomes iniciados por \"r\"");

println!("{}", familia_celebrone("r"));
}

fn familia_celebrone(filtro: &str) -> String {
let nomes = ["Rodrigo", "Renan", "Flávia", "Ivone", "Sofia",
"Robson", "Carol", "Pedro", "Flaviano", "Creonice"];
let mut nomes_filtrados = String::new();

for(_i, nome) in nomes.iter().enumerate() {
let mut nome_cortado : String = nome.to_uppercase()
.chars().take(filtro.chars().count()).collect();
let mut filtro_cortado : String = filtro.to_uppercase().to_string();

if nome_cortado == filtro_cortado {

nomes_filtrados.push_str(nome);
nomes_filtrados.push_str(", ");
}
}

return nomes_filtrados;
}

- Feito isso, compilei com rustc main.rs
- E rodei o comando ./main para ver o resultado
- O resultado foi exatamente: "Rodrigo, Renan, Robson, " (é, não retirei a última vírgula por pura preguiça, já passa da meia noite).
- Perceba que em alguns lugares usei mut, pois por padrão o Rust é imutável. Pode parecer loucura, mas se observarmos a quantidade de cagada que fazem em outras linguagens, faz sentido inverter esse padrão.
- Outra coisa curiosa é o _i ali no for. O compilador recomendou que eu coloque um _ no ínicio de variáveis que não são utilizadas.

Enfim, é isso. No geral eu gostaria de deixar registrado que esse evento foi muito bem organizado. Rico de conteúdo e me apresentou uma linguagem que eu desconhecia. Sem mencionar os Web Components nativos com polymer, mas isso vou deixar como spoiler.

Vlw, abraços e espero que gostem do Rust assim como eu gostei :)