segunda-feira, 5 de junho de 2017



Sábado passado, 03/06/2017 participei do NodeSchool Campinas pra falar um pouco sobre API's REST com HapiJS, um framework muito poderoso para criação de API's e Web Services mais robustos voltados a alta disponibilidade e microservices.

Site HapiJS: https://hapijs.com/tutorials

Repositório dos exemplos da Talk: https://github.com/msfidelis/hapijs-demo

Confira a transmissão Ao Vivo que rolou no Superlógica Labs:



Confira os Slides:



Entra lá no Meetup do pessoal do NodeSchool!

:)

TALK :: API's com HapiJS no NodeSchool Campinas

domingo, 21 de maio de 2017



Hoje o Nginx tá rolando solto aqui. Recomendo que veja o primeiro artigo onde montamos de maneira simplista um Port Foward utilizando o Nginx com proxy reverso.

Dessa vez, vamos utilizar o Nginx para fazer o que ele faz de melhor utilizando alguns recursos mais avançados que do ultimo post: Ser um proxy reverso de alta performance para servir conteúdo estático e fazer caching dos mesmos para acelerar a navegação de sites e etc. O Nginx é uma ferramenta muito versátil que pode trabalhar em conjunto com vários outros Web Servers e ferramentas.

As estratégias de caching são quase que obrigatórias quando falamos de web hoje em dia, e viver sem isso quando sua aplicação cresce, pode causar diversos problemas de performance e até mesmo impactar nos custos de cloud, com scaling de máquinas de forma não pertinente. Uma solução pra isso é criar um proxy gateway utilizando o Nginx como primeiro contato para que ele se encarregue de cachear todo conteúdo estático como HTML, CSS, JS e imagens da nossa aplicação para diminuir ou evitar um Overhead dos nosso servidores.

Vou exemplificar esse artigo com um case parecido com o do anterior, mas dessa vez vamos trabalhar servindo uma Dashboard qualquer na porta 1234 do Apache.



Vamos seguir os passos iniciais para a instalação.


Instalação do Nginx 

Neste exemplo, como de costume, eu estarei utilizando o Debian 8 Jessie para os testes, mas o procedimento de instalação será o mesmo para todas as distribuições Debian Like.
Após a instalação vamos confirmar se o serviço está Ok.


$ sudo apt-get install nginx 
$ sudo systemctl enable nginx
$ sudo systemctl start nginx 
$ sudo systemctl status nginx

A saída deve ser parecida com essa:

● nginx.service - A high performance web server and a reverse proxy server
   Loaded: loaded (/lib/systemd/system/nginx.service; enabled)
   Active: active (running) since Sun 2017-05-21 20:12:44 GMT; 9min ago
 Main PID: 1642 (nginx)
   CGroup: /system.slice/nginx.service
           ├─1642 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
           ├─1643 nginx: worker process
           ├─1644 nginx: worker process
           ├─1645 nginx: worker process
           └─1646 nginx: worker process

May 21 20:12:44 jessie systemd[1]: Started A high performance web server and a reverse proxy server.
May 21 20:21:19 jessie systemd[1]: Started A high performance web server and a reverse proxy server.
vagrant@jessie:~/teste$


Configuração do Proxy Reverso com Cache de conteúdo estático

Edite o arquivo de configuração do Nginx e adicione a linha do proxy_cache_path

$ vim /etc/nginx/nginx.conf

user www-data;
worker_processes 4;
pid /run/nginx.pid;

events {
        worker_connections 768;
        # multi_accept on;
}

http {

        ##
        # Basic Settings
        ##
        
        # Adicione essa linha 
        proxy_cache_path  /data/nginx/cache  levels=1:2    keys_zone=STATIC:10m inactive=24h  max_size=1g;

...

Agora vamos criar a pasta de armazenamento do Cache e o arquivo que vamos utilizar para separar as configurações do nosso servidor.


$ mkdir -p /data/nginx/cache
$ touch /etc/nginx/sites-enabled/proxy-cache.conf

No arquivo que acabamos de criar, vamos adicionar as seguintes linhas:

/etc/nginx/sites-enabled/proxy-cache.conf

    server {
        listen       80;

        # Location do conteúdo estático - Aqui vamos cachear tudo
        location ~* ^.+.(jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js)$ {

            # PROXY CACHE CONFIGS
            proxy_pass             http://127.0.0.1:1234;
            proxy_set_header       Host $host;
            proxy_cache            STATIC;
            proxy_cache_valid      200  1d;
            proxy_cache_use_stale  error timeout invalid_header updating http_500 http_502 http_503 http_504;

            #CORS - Conteúdo estático libere somente o GET
            add_header 'Access-Control-Allow-Origin' *;
            add_header 'Access-Control-Allow-Credentials' 'true';
            add_header 'Access-Control-Allow-Headers' 'Content-Type,Accept';
            add_header 'Access-Control-Allow-Methods' 'GET';

            #CACHE - Informações do Cache no Header
            add_header Cache-Control "public";
            add_header X-Proxy-Cache $upstream_cache_status;

            # Tempo de expiração
            expires 30d;
        }

        # Location do Proxy reverso - Aqui rodando o Apache convencional
        location / {

            # PROXY CACHE CONFIGS
            proxy_pass             http://127.0.0.1:1234;
            proxy_set_header       Host $host;
            proxy_cache            STATIC;
            proxy_cache_valid      200  1d;
            proxy_cache_use_stale  error timeout invalid_header updating http_500 http_502 http_503 http_504;

            # CORS
            add_header 'Access-Control-Allow-Origin' *;
            add_header 'Access-Control-Allow-Credentials' 'true';
            add_header 'Access-Control-Allow-Headers' 'Content-Type,Accept';
            add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, PATCH, DELETE, OPTIONS';

            # Status do Cache como Header no response
            add_header Cache-Control "public";
            add_header X-Proxy-Cache $upstream_cache_status;

            # Tempo de expiração do conteúdo cacheado - Aqui você pode pegar leva no cache
            expires 1d;
        }
    }

O que fizemos aqui:

Primeiramente nós criamos dois locations parecidos que vão bater na nossa configuração de proxy reverso.  As únicas diferenças são o tempo de cache, no caso 30 dias para o conteúdo estático e 1dia para o restante das solicitações.

No caso de você prover o uso de alguma API, recomendo retirar as configurações de cache do proxy_cache do location / ou diminuir o tempo de cache.

Também um pequeno detalhe do CORS que permite somente solicitações GET para o nosso conteúdo estático e liberamos os outros (mais utilizados) verbos HTTP para o restante da aplicação.

No proxy_pass, devemos informar o IP e a porta do nosso servidor original.
No exemplo eu estou provendo cache para uma aplicação que está na mesma máquina, porém rodando na porta 1234. Informe seu servidor ou load balance aqui.
Adicionamos um Header no response chamado X-Proxy-Cache, onde ele vai nos informar o status daquela solicitação mediante ao cache. No caso, as mais conhecidas vão ser HIT (veio do cache) e MISS (Não veio do cache, normalmente as primeiras solicitações após a limpeza ou vencimento do cache).

Agora vamos reiniciar o serviço e testar a aplicação:


$ rm -rf /data/nginx/cache/*
$ systemctl restart nginx

Acessando nossa Dashboard via navegador, podemos ver algo diferente das demais solicitações:

Nos conteúdos estáticos, podemos ver os Headers que adicionamos, o CORS o vencimento do cache (30 dias depois da sua solicitação) e o X-Proxy-Cache como HIT, dizendo que veio do cache (A primeira solicitação virá MISS).




Olhando mais de perto as solicitações de conteúdo fora dos assets, no caso o HTML da página podemos ver o mesmo resultado, porém com o cache para 1 dia.


Podemos testar com mais detalhes com o curl, para visualizar somente os headers com o parâmetro -I



$ curl -I http://192.168.1.53



$ curl -I http://192.168.1.53/style.css


Limpando o cache do Nginx

Para limpar o cache que o Nginx vai gerar, basta apagar o conteúdo da pasta que criamos anteriormente.

$ rm -rf /data/nginx/cache/*


Espero ter ajudado! :)

Nginx :: Criando um servidor de Proxy Reverso e Caching de Conteúdo




Esse artigo vai mostrar a maneira mais simples de fazer um proxy reverso com intuito de Port Forward utilizando o servidor de alta performance Nginx.

Site do Nginx: https://nginx.org/en/
Documentação: https://www.nginx.com/resources/wiki/

Vamos supor que nós criamos um serviço que rode na porta 1234 de uma máquina qualquer, e precisar fazer com o Nginx crie um proxy reverso da porta 80 para a porta 1234, fazendo com que o mesmo funcione como uma ponte de ligação entre o cliente e o serviço. Para exemplificar, vamos supor que tenhamos um servidor Apache 2.4 rodando na porta 1234 do servidor.



Instalação do Nginx


Para fazer a instalação do Nginx, você deverá acessar a documentação para mais detalhes. Neste exemplo eu estarei utilizando o Debian 8 Jessie para os testes, mas o procedimento de instalação será o mesmo para todas as distribuições Debian Like. Após a instalação vamos confirmar se o serviço está Ok.


$ sudo apt-get install nginx 
$ sudo systemctl enable nginx
$ sudo systemctl start nginx 
$ sudo systemctl status nginx

● nginx.service - A high performance web server and a reverse proxy server
   Loaded: loaded (/lib/systemd/system/nginx.service; enabled)
   Active: active (running) since Sun 2017-05-21 20:12:44 GMT; 9min ago
 Main PID: 1642 (nginx)
   CGroup: /system.slice/nginx.service
           ├─1642 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
           ├─1643 nginx: worker process
           ├─1644 nginx: worker process
           ├─1645 nginx: worker process
           └─1646 nginx: worker process

May 21 20:12:44 jessie systemd[1]: Started A high performance web server and a reverse proxy server.
May 21 20:21:19 jessie systemd[1]: Started A high performance web server and a reverse proxy server.
vagrant@jessie:~/teste$

Pra verificar se está tudo Ok, vamos acessar a porta 80 do servidor


Criando o proxy reverso 

Vamos criar um arquivo chamado apache-proxy.conf onde vamos configurar nosso proxy reverso para fazer nosso redirect inicial do Nginx para o Apache

sudo vim /etc/nginx/sites-available/apache-proxy.conf

/etc/nginx/sites-available/apache-proxy.conf


    server {
        listen       80;
        server_name  localhost;
        access_log  /var/log/nginx/proxy-apache.log;

        location / {
                proxy_pass      http://127.0.0.1:1234;
        }
    }

Como vamos utilizar a porta 80 do servidor, devemos deletar o arquivo de configuração /etc/nginx/sites-enabled/default  que contém algumas configurações que ocupam essa porta. Em seguida vamos criar um link simbólico da do arquivo de configuração do proxy reverso para dentro da pasta sites-enabled antes de reiniciar o serviço.

$ sudo rm /etc/nginx/sites-enabled/default
$ sudo ln -s /etc/nginx/sites-available/apache-proxy.conf /etc/nginx/sites-enabled/apache-proxy.conf

$ sudo systemctl restart nginx 

Agora com o serviço reiniciado, vamos acessar a porta 80 do servidor.


Essa é a forma mais simples de fazer o serviço de redirecionamento de portas entre serviços utilizando o Nginx.

Espero ter ajudado :)

Nginx :: Criando um serviço de proxy reverso rapidamente

segunda-feira, 10 de abril de 2017


Aqui vai minha Stack básica de PHP 7.0. Apenas mais um daqueles posts que eu mato uma nota no meu Google Keep e faço nascer um post aqui pra comunidade. Essa é minha Stack default, ou seja, o general que fica ao meu lado na guerra. Uso esse esquema também nas minhas Dockerfiles também. Espero que ajude!

Instalação dos repositórios no Ubuntu Server 16.**

Instalação do Software Properties (Caso não houver) 
$ sudo apt-get install software-properties-common -y

Instalação do repositório do PHP 7.0 no Ubuntu

$ sudo add-apt-repository ppa:ondrej/php
$ sudo apt-get update 

Instalação dos repositórios no Debian Jessie

Instalação do repositório do PHP 7.0 no Debian
$ echo "deb http://packages.dotdeb.org jessie all" >> /etc/apt/sources.list 

$ wget https://www.dotdeb.org/dotdeb.gpg
$ sudo apt-key add dotdeb.gpg
$ sudo apt-get update

Instalação do PHP 7.0 no Debian Jessie e Ubuntu 16.xx

Instalação uniforme para ambos as distribuições
$ sudo apt-get install php7.0  php7.0-bcmath php7.0-bz2 \
php7.0-cli php7.0-common php7.0-curl php7.0-dev php7.0-fpm \
php7.0-gd php7.0-interbase php7.0-intl php7.0-json php7.0-mbstring \ 
php7.0-mcrypt php7.0-mysql php7.0-opcache \
php7.0-pspell php7.0-readline php7.0-recode \
php7.0-soap  php7.0-tidy php7.0-xml php7.0-xmlrpc php7.0-xsl php7.0-zip -y 


E caso necessite de mais algum pacote do PHP, você pode encontrá-lo facilmente

$ sudo apt-cache search php7

Espero ter ajudado :)

PHP :: Instalação do PHP 7.0 em Ambientes Ubuntu 16.04 e Debian Jessie

quarta-feira, 5 de abril de 2017



Há um tempo fiz um post explicando a instalação do Fish Shell, uma shell voltada a produtividade que eu venho utilizando assiduamente em todos os computadores que eu tenho acesso (sério). E hoje eu venho trazer uma notinha rápida sobre um componente do Fish chamado Fishmark.

O Fishmark é um componente que se integra ao Fish Shell e te permite criar bookmarks em diretórios a sua escolha e te permite navegar até eles muito rápido. Ele é baseado no Bashmark, um outro projeto bem bacana que funciona da mesma forma porém para o Bash. Vale a pena dar uma olhada também

Git do projeto: https://github.com/techwizrd/fishmarks

Instalação Automática

$ curl -L https://github.com/techwizrd/fishmarks/raw/master/install.fish | fish


Instalação Manual

1. Clone o projeto para ~/.fishmarks
$ git clone http://github.com/techwizrd/fishmarks.git

2. Dê um source no arquivo para recarregar as configurações do Fish, ou inicie uma nova sessão
$ . ~/.fishmarks/marks.fish

# Ou

$ fish


Usage:


s <bookmark_name> - Salva o diretório atual com o nome de "bookmark_name"
g <bookmark_name> - Vai para o diretório com nome associado a "bookmark_name" (cd) 
p <bookmark_name> - Printa o caminho do bookmark associado a "bookmark_name"
d <bookmark_name> - Deleta o bookmark
l - lista todos os bookmarks disponívels

Exemplo:




Espero ter ajudado :)

Fish :: Navegando rapidamente entre diretórios com Fishmarks


Eu sempre me achei um cara preguiçoso. E nem de longe vejo isso como uma coisa ruim (pra mim). Desde que me conheço como profissional sempre fui uma exímio automatizador preguiçosos, e absorvi isso pra minha vida pessoal de uma forma bem bacana. E nessas indas e vindas no dia a dia de um preguiçoso nato, eu descobri o mingit. O mingit (Minimalist Git) é um projeto Open Source de um cara que eu achei no dev.to. Eu

Git do Projeto: https://github.com/evansendra/mingit

Um exemplo de Git Aliases

Você precisa editar o arquivo de configurações do git do seu usuário presente na sua home, e customizar as entradas dentro da tag [alias] de forma parecida com:

$ vim ~/.gitconfig
[alias]
  co = checkout
  ci = commit
  st = status
  br = branch
  hist = log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short
  type = cat-file -t
  dump = cat-file -p

$ git co branchdaabobora # git checkout branchdaabobora

É possível até mesmo customizar esses "git aliases" a partir dos alias do próprio bash editando o .profile do seu usuário:

$ vim ~/.profile
alias gs='git status '
alias ga='git add '
alias gb='git branch '
alias gc='git commit'
alias gd='git diff'
alias go='git checkout '
alias gk='gitk --all&'
alias gx='gitx --all'

alias got='git '
alias get='git '

O Mingit é basicamente um conjunto de alias mais minimalistas ainda, pra quem tem preguiça de criar até mesmo seus próprios alias. Assim:

$ git commit -m "esse código destrói a Lua"

ficaria... 

$ g c "esse código destrói a Lua"

Um resumo dos aliases disponíveis

g a .                   // git add .
g b other-branch        // git branch other-branch
g c "made some changes" // git commit -m "made some changes"
g commit --amend        // it also works with regular subcommands
g co master             // git checkout master
g co mas<TAB><TAB>      // auto-complete still works! 🙌
g d                     // git diff
g f                     // git fetch
g i                     // git init 
g m hotfix              // git merge hotfix
g pll                   // git pull
g psh                   // git push
g s                     // git status


Instalando o Mingit

O Mingit é um pequeno Shellcode que pode ser instalado diretamente pelo NPM.

$ npm install -g mingit

Espero ter ajudado :)


Git :: Usando o Git Como Um Preguiçoso com Aliases e Mingit

 
Nanoshots | Open Source Security, Linux e Tutoriais © 2015 - Designed by Templateism.com