Mão na massa – Integração contínua com FTP em hospedagem compartilhada

Dando continuidade ao post sobre integração contínua com FTP (Se não viu segue o link).

Vamos a como resolvi esse meu problema.

Não vou explicar sobre o Git, esse já tem sua documentação fácil.

Começando com o Bitbucket, ative o pipeline, em seu projeto Configurações > Pipelines > Settings (O Bitbucket ainda não fez toda a tradução)

Criei o arquivo bitbucket-pipelines.yml na raiz do projeto, ele é o responsável pela build. Um exemplo simples, apenas rodando o PHPUnit é esse:

Pronto, com isso a cada commit que for feito, o Bitbucket vai disparar a pipeline e com isso gerar o build, com isso vamos ter o seguinte resultado:

Com o processo de build e testes automatizado, podemos pensar no deploy. Para isso usei o DeployBot. Quando criamos o primeiro repositório, o DeployBot faz uma interface passo a passo, mas, como meu plano é o gratuito, só tenho um repositório e ele esta em uso. Vou mostrar as configurações, ai você pode ajustar 🙂

No primeiro passo, criamos o ambiente, no meu caso, apenas produção (no test no fear).

E suas configurações.

Com a configuração de deploy manual, eu preciso mandar fazer o deploy todas as vezes, se esse servidor fosse de QA, facilmente estaria no automático.

Depois de criar o ambiente, é necessário criar os servidores, essa parte é o simples apontamento para onde os arquivos de deploy devem ir.

Configuração de FTP.

No seu cPanel.

Agora que já sabe para onde vai, hora de ajustar as dependências

Outra coisa que podemos fazer aqui, é colocar arquivos com base no ambiente, isso ajuda nas configurações de banco de dados por exemplo.

Essa parte eu não consegui entender bem, mas, em meus testes, sem usar isso a próxima parte da problema…

Aqui ele simplesmente instancia o docker e executa “php -v”, só para saber a versão mesmo, sem segredo.
Essa é a parte da mágica, o DeployBot, só vai executar essa parte caso o composer.json seja alterado, isso é muito bom, pois não vai enviar a pasta vendor sem a necessidade

Agora é só partir para o deploy.

Quando você executa o deploy a primeira vez, ele vai enviar tudo (TUDO) e ficar mais ou menos assim.

Carregando as dependências.Enviando os arquivos.Quando precisar fazer outro deploy, vai enviar apenas a diferença.Aqui, você também pode ver o arquivo de configuração por ambiente foi enviado.

Agora é só curtir 🙂

Apigility e Doctrine 2

Hoje vou explicar como juntar o Doctrine 2 com o Apigility. Espero que isso ajude vocês da forma como me ajudou 🙂

Baixe o Apigility por aqui.
Depois de extrair o conteúdo, inicie o servidor.

php -S 0.0.0.0:8888 -t public public/index.php

Agora vamos criar uma API
Criar o serviço REST

Depois altere as configurações do aplicativo, a Entity precisa ser alterada
Local da Entity

Agora, vamos as configurações

Primeiro vamos adicionar o Doctrine 2 como dependência, isso pode ser feito de duas formas, diretamente no arquivo.

"doctrine/doctrine-orm-module" : "0.8.*"

ou

php composer.phar require "doctrine/doctrine-orm-module" "0.8.*"

Se você fez do primeiro jeito, atualize as dependências, pela segunda forma isso não é preciso.

php composer.phar update

Agora, precisamos adicionar os módulos do Doctrine 2 no application.config.php.

'DoctrineModule',
'DoctrineORMModule',

No module.config.php, adicione a configuração para que o zend processe o doctrine

'doctrine' => array(
    'driver' => array(
        'user_entities' => array(
            'class' => 'Doctrine\ORM\Mapping\Driver\AnnotationDriver',
            'cache' => 'array',
            'paths' => array(
                0 => __DIR__ . '/../src/User/Entity',
            ),
        ),
        'orm_default' => array(
            'drivers' => array(
                'User\Entity' => 'user_entities',
            ),
        ),
    ),
),

Para finalizar as configurações, crie o arquivo que configura a conexão com o banco e depois crie na pasta data/ um arquivo database.sqlite, ele é o seu banco de dados.

A entidade User precisa ser alterada de lugar, mova ela para /src/Entity e renomeie conforme gist.

Quando as configurações e a entidade estiver criada, falta gerar as tabelas.

php public/index.php orm:schema-tool:create

Caso seja preciso atualizar o banco de dados

php public/index.php orm:schema-tool:update --force

Agora altere os arquivos que o Apigility gerou

UserResource.php

UserCollection.php

UserResourceFactory.php

Como aqui é para teste, eu inseri um registo diretamente no banco, depois disso, só usar algum programa que faz post rest, eu uso o RESTClient do Firefox.

Executando o get list

http://localhost:8888/user

Get Collection

Executando o get

http://localhost:8888/user/1

Get ID

O código pode ser baixado pelo github aqui

Qualquer dúvida só mandar e-mail ou postar aqui.

Mão na massa Restful e Zend Framework 2

Mais uma postagem da séria Mão na massa. Aqui vamos ter uma aplicação Restful usando Zend Framework 2, esse tipo de aplicação é largamente utilizada para criação de APIs e arquitetura SOA.

Particularmente eu gosto do Rest por ele ser simples, acredito que essa seja a maior vantagem dele. Muitas pessoas dizem que ele é pior do que o SOAP por questões de segurança e bla bla bla. Para você ter uma ideia, podemos usar o OAuth no Rest, acredito que isso seja o suficiente para mostrar que é seguro. Outro motivo é o fato de usar JSon, eu simplesmente acho mais legal que XML, nada mais a declarar. 🙂

Depois de falar esse monte de besteiras para você, vamos ao escopo dessa mão na massa.
Fazer um sistema que leia um CEP informado e retorne o endereço completo, o retorno deve ser em JSon e XML.
Para isso vamos fazer algo bem tranquilo, vamos apenas retornar o método get($id), com os dados fixos em um array.

Se você não tiver um ambiente pronto, eu recomendo usar o Vagrant, aqui uma postagem sobre ele e uma de como configrar um servidor LAMP.
Primeiramente vamos montar o ambiente de desenvolvimento usando o Skeleton que a Zend disponibiliza, eu tenho um fork dele na minha conta do github e é ele que vamos usar. Download Skeleton.

Depois de descompactar e deixar pronto para uso, vamos as modificações.

Sempre tenho problemas na versão do PHP, por isso vamos usar o Zend Framework 2.2, precisamos alterar o composer.

Agora vamos executar o composer

php composer.phar self-update
php composer.phar install

Assim que ele terminar de executar já podemos consultar o site, no meu caso http://cepsample.local:8080.

restfullsample

Vamos definir que a nossa URL para fazer a consulta de CEP será “/api/cep[.:format]/[:CEP]”. Como exemplos:

http://cepsample.local:8080/api.json/cep/06460000

ou

http://cepsample.local:8080/api.xml/cep/06460000

Para fazer isso, precisamos criar uma rota na nossa aplicação para ela responder por esse endereço.

cepsample/module/Application/config/module.config.php (link GitHub)

return array(
    'router' => array(
        'routes' => array(
        ...
          'cep' => array(
              'type' => 'Segment',
              'options' => array(
                  'route' => '/api/cep[.:format]/[:id]',
                  'constraints' => array(
                      'format' => '(json)',
                  ),
                  'defaults' => array(
                      'controller' => 'ApplicationControllerCep',
                      'format' => 'json',
                  ),
              ),
          ),

No mesmo arquivo, procure o indíce “controllers”, ele deve se parecer com isso

'controllers' => array(
    'invokables' => array(
        'ApplicationControllerIndex' => 'ApplicationControllerIndexController'
    ),
),

E deve ficar assim

'controllers' => array(
    'invokables' => array(
        'ApplicationControllerIndex' => 'ApplicationControllerIndexController',
        'ApplicationControllerCep' => 'ApplicationControllerCepController'
    ),
),

Com o redirect pronto, podemos iniciar a construção do método em Rest

No caminho “modules/Application/src/Application/Controller” crie um arquivo chamado “CepController.php”, ele deve ser assim:

Agora quando acessarmos a URL ele vai nos mostrar o array que foi definido no método get($id). Se não passarmos nada depois no CEP na URL, o retorno será em JSon, podemos passar XML também.

restfull_final_sample

Esse código por ser baixado pelo meu GitHub aqui.

Servidor LAMP

Hoje vou explicar como podemos criar um servidor LAMP. Essa postagem será útil se você utiliza o vagrant, sua máquina ou queria criar um servicor dentro da Amazon AWS, que é o ambiente que vamos utilizar.

Depois criarmos o servidor na AWS, precisamos acessar ele via SSH.
A primeira coisa que precisamos fazer é atualizar a lista de pacotes.

sudo apt-get update

Assim que terminar de atualizar os pocotes você pode dar início as instalações.

O primeiro passo é instalar o índio veio do Apache.

sudo apt-get install apache2

Agora, vamos a configuração de um site no apache. Com esse arquivo de exemplo, vamos montar o site.

Copie o conteúdo acima para o arquivo abaixo.

sudo nano /etc/apache2/sites-available/sample.conf

O servidor vai começar a responder para esse site apenas quando for ativado.

a2ensite sample.conf
sudo a2enmod rewrite
sudo service apache2 restart

O comando “sudo a2enmod rewrite” é para ativar o módulo de reescrita de URL do apache, ele é um adicional para o nosso caso, mas é obrigatório para o Zend, por esse motivo já coloquei ele aqui.

O segundo passo é o MySQL. Essa parte é sem segredos, vai executar o comando e ele vai pedir usuário e senha no processo.

sudo apt-get install mysql-server-5.5

Por fim, o PHP.

sudo apt-get install php5 php5-mysql

Aqui eu passei 2 pacotes para ele baixar, o “php5” é o PHP em si, o “php5-mysql” é o driver para do PHP para o MySQL.

Com tudo feito, fica assim:
Apache Sample