Deploying Sendy Using AWS ElasticBeanstalk and Docker

sendy-300x118 In this post I’m going to guide you through a step-by-step on how to deploy your Sendy installation using AWS ElasticBeanstalk and Docker. Keep in mind that this is a production ready setup so brace yourself.

The AWS Resources

Here is a list of what you need to do before going ahead.

  1. Create an ElasticBeanstalk Application (e.g Sendy).
  2. Create an ElasticBeanstalk Environment (e.g sendy-production).
    1. You can deploy the Sample Application for now.
    2. Once your environment is created make a note of your Environment ID located on your environment dashboard right beside your DNS entry. (e.g Environment ID: e-xxxxxxxxxxx).
  3. Create a EC2 Security Group to be used by your RDS MySQL Instance (e.g: rds-sendy-production).
    1. Inbound: Open this tab and make sure you allowed your ElasticBeanstalk Instances can reach your RDS. To do so you need to locate the name of the Security Group created by your ElasticBeanstalk Environment. Just go to your EC2 Security Groups Section. And locate the ID of the security group that possessed your ElasticBeanstalk Environment ID.
    2. It will look kind of like this:
    3. You need to do that because your environment is elastic and every new created instance needs to inherit its permission to access the RDS instance.
  4. Create your RDS MySQL instance and attach the EC2 Security Group created on the previous step. Further configurations is up to you.
  5. Create a SSD or Magnetic Volume on the same Availability Zone of your Elastic Beanstalk Environment Instances. Attention to the availability zone or your deployment will fail because EC2 Instances can’t attach volumes outside of its availability zone. After doing that take a note on your Volume ID (e.g vol-XXXXXXXX).
  6. Install the awsebcli.

The Deploy Setup

Assuming that you’re already inside your Sendy’s folder you need to create a few files.


FROM php:7.0.8-apache

RUN a2enmod rewrite && \
    docker-php-ext-install mysqli gettext

ENV APP_HOME /var/www/html



Notice that I’m using the official php + apache2 docker image. I need to create my own Dockerfile because of Sendy’s dependencies like mysqli and gettext.


    environment: sendy-production
  application_name: sendy
  default_ec2_keyname: YOUR-EC2-KEYNAME
  default_platform: Docker 1.11.1
  default_region: us-east-1
  profile: null
  sc: null

This file is important when your are about to deploy your application to ElasticBeanstalk.

  "AWSEBDockerrunVersion": "1",
  "Ports": [
      "ContainerPort": "80"
  "Volumes": [
      "HostDirectory": "/uploads",
      "ContainerDirectory": "/var/www/html/uploads"
       "HostDirectory": "/session",
       "ContainerDirectory": "/var/www/html/session"
  "Logging": "/var/log/apache2/"

Ports: By default apache is running on port 80, no big deal here.
Volumes: The most important thing to notice on the code above is those “Volumes”. Sendy uses the the uploads/ directory to save everything you upload to its system so it’s very important for you to have those volumes mapped from the Docker Host into your containers to make sure that in case you need to restart your containers you don’t lose your persisted data (docker containers are stateless!).

The /session:/var/www/html/session is because it is where php is saving logged user sessions. Its better to save sessions outside of the application container. It make sure that every new deployment you don’t need to clean your cookies and login again (it sucks, I know!).


    command: "aws ec2 attach-volume --region us-east-1 --volume-id YOUR_VOLUME_ID_HERE --instance-id $(curl -s --device /dev/xvdf"
    ignoreErrors: true
    command: "sleep 20"
    command: "mkdir /uploads"
    test: "[ ! -d /uploads ]"
    command: mount /dev/xvdf /uploads
    ignoreErrors: true
    command: if find /uploads -maxdepth 0 -empty | read v; then mkfs -t ext4 /dev/xvdf; fi
    command: "mount /dev/xvdf /uploads"
    ignoreErrors: true
    command: "chmod -R 777 /session && chmod -R 777 /uploads"
    ignoreErrors: true

01mount: Replace the YOUR_VOLUME_ID_HERE by your Volume ID created before. Also make sure that –region us-east-1 is correct. This file will make sure that we will be using the Volume created earlier exclusive to our uploads and your data will never be lost in case you explode your machine somehow.
02wait: The commend aws ec2 attach-volume is async so we need this otherwise further commands would fail.
03mkdir: Create the /uploads dir in case it doesn’t exists.
04trymount and 05: When you first create a EC2 Volume you need to make sure that it has a file system in it so this is what it does.
06mount: Uses the Volume we created for the /uploads folder.


    mode: "000755"
    owner: root
    group: root
    content: |
      #!/usr/bin/env bash
      set -x
      docker run -v /uploads:/var/www/html/uploads --rm aws_beanstalk/staging-app chown -R www-data: /var/www/html/uploads
    group: root
    owner: root
    mode: "000755"
    content: |-
      #! /usr/bin/python

      Modifies nginx configuration file on AWS Elastic Beanstalk to support WebSocket connections.

      import os
      import re

      NGINX_CONF_FILE = '/etc/nginx/sites-available/elasticbeanstalk-nginx-docker-proxy.conf'
      NGINX_CONFIG = """
      # nginx.conf
      # v1.0.4

      map $http_upgrade $connection_upgrade {
        default   "upgrade";
        ""      "";

      server {
        listen 80;

        gzip on;
        gzip_comp_level 4;
        gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
        client_max_body_size 100M;

        location ~ "^/assets/" {
          root /var/app/current/public;
          gzip_static on;
          expires max;
          add_header Cache-Control public;
          add_header ETag "";

        location / {
          proxy_pass      http://docker;
          proxy_http_version  1.1;

          proxy_set_header  Connection           $connection_upgrade;
          proxy_set_header  Upgrade              $http_upgrade;
          proxy_set_header  Host                 $host;
          proxy_set_header  X-Real-IP            $http_x_real_ip;
          proxy_set_header  X-Forwarded-For      $http_x_forwarded_for;

      def has_same_nginx_file_version():
        f = open(NGINX_CONF_FILE, "r")
        conf =
        ret =, conf)

        return ret != None

      def write_nginx_conf_file():
        f = open(NGINX_CONF_FILE, "w")

      def restart_nginx():
        print("-- service nginx restart")
        os.system("service nginx restart")

      def main():
        if has_same_nginx_file_version():
          print("-- already configured, do nothing.")
        else :

      if __name__ == "__main__":

The file above is necessary because apache runs your application with www-data user and this user doesn’t exists on your Docker Host. And the second file is for overwriting nginx’s beanstalk configuration for accepting upload of bigger files.


/* MySQL database connection credentials (please place values between the apostrophes) */
$dbHost = $_ENV['MYSQL_DATABASE_HOST']; //MySQL Hostname
$dbUser = $_ENV['MYSQL_DATABASE_USER']; //MySQL Username
$dbPass = $_ENV['MYSQL_DATABASE_PASSWORD']; //MySQL Password
$dbName = $_ENV['MYSQL_DATABASE_NAME']; //MySQL Database Name

Add these to your .htaccess file:

# for enabling upload of bigger CSV files
LimitRequestBody 104857600
php_value max_execution_time 0
php_value post_max_size 60M
php_value upload_max_filesize 50M

# to avoid session problems originally saved to /tmp.
php_value session.save_path '/var/www/html/session'

Make sure that you are using environment variables on that file so we can inject them into your ElasticBeanstalk Environment.

Set your database configuration as Environment Variables


Deploy it

Commit your changes and then:

eb deploy sendy-production

Boom! Now make sure that you follow Sendy’s Guide Lines in order to setup your app correctly.

Let me know if you have any questions on the comments section bellow. Maybe some detail is missing and I could add it to the post. Remember! Sharing is caring! ;-D

Posts Relacionados:

Abreviando um texto sem cortar palavras no PHP

Olá Pessoal!
Como apresentar soluções para problemas cotidianos, é um dos objetivos deste blog, vou compartilhar com vocês uma solução que escrevi para que vocês possam abreviar um texto, sem cortar qualquer palavra pela metade.

É extremamente chato, quando estamos lendo o resumo de uma notícia e nos deparamos com uma palavra cortada, dificultando a compreensão do texto. É feio, principalmente para a estética do layout.

A maioria das funções escritas (em qualquer linguagem) para abreviar um texto, acabam cortando o texto pela metade. Você passa 2 parâmetros: String Texto e Int Limite.

Texto é o texto própriamente dito, e Limite é o tamanho máximo que o texto deve ocupar. Se o texto for maior que 250 caractéres, o script abrevia o texto sem estourar o limite e sem cortar palavras pela metade, caso contrário, deixa o textocomo está.

A solução que escrevi foi esta:

public function abreviaString($texto, $limite, $tres_p = '...')
    $totalCaracteres = 0;
    //Retorna o texto em plain/text
    $texto = Biblioteca::somenteTexto($texto);
    //Cria um array com todas as palavras do texto
    $vetorPalavras = explode(" ",$texto);
    if(strlen($texto) <= $limite):
        $tres_p = "";
        $novoTexto = $texto;
        //Começa a criar o novo texto resumido.
        $novoTexto = "";
        //Acrescenta palavra por palavra na string enquanto ela
        //não exceder o tamanho máximo do resumo
        for($i = 0; $i <count($vetorPalavras); $i++):
            $totalCaracteres += strlen(" ".$vetorPalavras[$i]);
            if($totalCaracteres <= $limite)
                $novoTexto .= ' ' . $vetorPalavras[$i];
            else break;
    return $novoTexto . $tres_p;

Note que eu chamei uma função estática chamada somenteTexto(). Quem quiser o fonte dela e saber como ela está implementada, está ai:

    public static function somenteTexto($string)
        $trans_tbl = get_html_translation_table(HTML_ENTITIES);
        $trans_tbl = array_flip($trans_tbl);
        return trim(strip_tags(strtr($string, $trans_tbl)));

Esta é a solução enviada pelo Carlos André Ferrari nos comentários do blog:

function abreviaString($texto, $limite, $tres_p = '…') {
  //Retorna o texto em plain/text
  $texto = Biblioteca::somenteTexto($texto);

  if (strlen($texto) <= $limite) 
    return $texto;
  return array_shift(explode('||', wordwrap($texto, $limite, '||'))) . $tres_p;

É importante que, antes de abreviarmos um texto, recebermos o texto puro, livre de tags htmls, scripts ou qualquer outra coisa que não faça parte do texto. Quando isso ocorre, dificulta a abreviação pois o algoritmo não sabe o que é texto e o que é metacaracter.

E é isso aí pessoal, o código está bem comentádo e documentado, caso vocês tenham alguma dúvida, fiquem a vontade para perguntar nos comentários.

Qualquer outra implementação que vocês tenham, que faça a mesma coisa, até mesmo em outras linguagens, o share é totalmente bem-vindo.


Posts Relacionados:

Screenshots com PHP

Salvar screenshots de um site não é uma tarefa muito comum de um programador, porém, esta é uma tarefa interessante de ser feita. Existem algumas soluções interessantes para se resolver esta tarefa, porém, existe um cara em especial que me chamou a atenção e atendeu muito bem as minhas necessidades. Requisito para prosseguir com a solução apresentada neste post é instalar o wkhtmltoimage. Se você acessar o site do projeto vai ver que o nome dele é wkhtmltopdf e não wkhtmltoimage, como é mencionado. O wkhtmltoimage existe nos downloads do projeto, você só precisa instalar a versão adequada para o seu sistema operacional. Tem versões para Linux, Mac e Windows. Vou guiá-los com base no texto Taking screenshots of websites with PHP.

O wkhtmltoimage é um simples utilitário para ser executado via shell que faz a conversão de HTML para imagem usando o WebKit Engine e QT. Não é bem uma conversão. A ferramenta renderiza o endereço requisitado utilizando o WebKit Engine e tira um screenshot desta renderização utilizando o QT.

Fazendo sua primeira screenshot

Levando em consideração que você já tenha o wkhtmltoimage instalado corretamente, abra o seu terminal e digite:

wkhtmltoimage google.jpg

O código acima vai converter toda a representação HTML do Google e vai converter isso para jpg usando o wkhtmltoimage.

Customizando a saída

O comando wkhtmltoimage tem uma série de opções:

  • Desabilitar a renderização de imagens.
  • Controlar a qualidade da imagem de output.
  • Salvar o screenshot com uma resolução específica.
  • Salvar uma região especifíca do screenshot (crop).
  • Desabilitar o javascript da pagina requisitada.


//renderiza sem imagens
wkhtmltoimage --no-images google.jpg

//não carrega os javascripts
wkhtmltoimage --no-javascript google.jpg

//reduz a qualidade da imagem de output
wkhtmltoimage --quality 50 google.jpg

//personaliza a largura e a altura do screenshot
wkhtmltoimage --height 600 --width 1800 google.jpg

//faz um crop de 300x300 pixels partindo do eixo x0 e y0
wkhtmltoimage --crop-h 300 --crop-w 300 --crop-x 0 --crop-y 0 google.jpg

Utilizando com PHP

Como já era de se imaginar, toda esta façanha não é feita somente com PHP. Você precisa da ajuda de alguns caras e para que o PHP consiga executar estes comandos, vamos precisar da ajuda de um método chamado shell_exec do PHP. Também podemos utilizar um wrapper escrito em PHP5 que abstrai os métodos do wkhtmltoimage e wkhtmltopdf chamado Snappy escrito em PHP5 do PHP.

Método 1: shell_exec

shell_exec('./wkhtmltoimage --quality 50 google.jpg');

Método 2: Snappy


namespace Knplabs\Snappy;


/* 'wkhtmltoimage' executable  is located in the current directory */
$snap = new Image('./wkhtmltoimage');

/* Displays the website index page screenshot in the browser */
header("Content-Type: image/jpeg");


Com alguns métodos adicionados…


namespace Knplabs\Snappy;


$options = array('zoom' => 0.5, 'no-images' => true);

/* 'wkhtmltoimage' executable  is located in the current directory */
$snap = new Image('./wkhtmltoimage-i386',$options);

/* Displays the website index page screen-shot in the browser */
header("Content-Type: image/jpeg");


É isso aí!

Qualquer dúvida, estou à disposição.

Posts Relacionados:

Treinamento PHPUnit Gratuíto

Dia 4 de novembro, Nick Belhomme criou um treinamento gratuito para PHPUnit e divulgou em seu blog no formato SlideShare. Para que não está por dentro, PHPUnit é uma ferramenta criada por Sebastian Bergmann para criamos suites de testes dentro de nossas aplicações PHP para garantirmos as funcionalidades e entrega de nossa aplicação. A abrangência da ferramenta é gigantesca, da pra fazer muita coisa. Requisitos de funcionalidade, navegação, integração, integridade etc. Se você nunca ouviu falar de TDD (Test Driven Development) esta é a sua chamada. TDD é umas das vertentes do XP (Extreme Programming) onde você desenvolve toda a sua aplicação orientada a testes. Se serve de atrativo e porcamente falando, TDD é a forma que temos de garantir o funcionamento de todas as funcionalidades do software estão funcionando, incluindo suas camadas. Protege sua aplicação do famoso “Corrige aqui, Quebra alí”. O treinamento é em inglês e está logo abaixo.

Post rápido. Como alguns já sabem, agora eu trabalho como PHP Engineer na LBS Local (Apontador & MapLink) em São Paulo e o tempo tem ficado bem corrido. Sempre que der vou tentar divulgar por aqui bons materiais que vão acrescentar na vida acadêmica e profissional de cada um. Se não gosta de esperar, estou diáriamente divulgando bons links no meu twitter, follow me!

Posts Relacionados:

Capturando miniatura de vídeos com PHP

Hoje vamos falar de um assunto bastante divertido e que é de muita utilidade para todos nós. Vamos aprender como capturar a miniatura (thumbnail) de um vídeo em PHP e posteriormente salva-las no HD. Todo serviço que trabalha com algum tipo de mídia precisa de algumas ferramentas para fazer esta manipulação. O PHP não oferece suporte utilizando funções nativas para manipular arquivos de audio ou vídeo. Por isso, vocês precisam de 3 coisas muito importantes que são descritas logo a frente para seguirmos com este artigo.


  • ffmpeg-0.4.9_pre1 ou superior.
  • ffmpeg-php 0.5.3 ou superior.
  • gd-2.0 ou superior. (a versão que vem compilada com o PHP funciona também)

obs: Neste artigo não é meu objetivo ensinar a fazer a instalação destes recursos pois com uma rápida googada você resolve o problema.

O que é o ffmpeg?

O ffmpeg é um conjunto de bibliotecas de uso livre e open-source que oferece um suporte completo para você converter e interagir com praticamente qualquer tipo de mídia.

O que é o ffmpeg-php?

O ffmpeg-php é uma extensão php desenvolvida para que nós, programadores PHP, possamos interagir com o ffmpeg sem utilizarmos a “perigosa” função system() (e derivadas) do PHP. Mas vale lembrar que ela cobre “em partes” as funções do ffmpeg. Você não consegue com ffmpeg-php converter vídeos por exemplo, mas com o ffmpeg você consegue.

Recebendo as informações do vídeo com PHP

Antes de começar a brincar com o vídeo, nós precisamos aprender como pegar as informações do vídeo. O ffmpeg-php permite que você acesse estas informações do video:

//Return the duration of a movie or audio file in seconds.
//Return the number of frames in a movie or audio file.
//Return the frame rate of a movie in fps.
//Return the path and name of the movie file or audio file.
//Return the comment field from the movie or audio file.
//Return the title field from the movie or audio file.
//alias $movie->getArtist()	Return the author field from the movie or the artist ID3 field from an mp3 file.
//Return the copyright field from the movie or audio file.
//Return the artist ID3 field from an mp3 file.
//Return the genre ID3 field from an mp3 file.
//Return the track ID3 field from an mp3 file.
//Return the year ID3 field from an mp3 file.
 //Return the height of the movie in pixels.
//Return the width of the movie in pixels.
//Return the pixel format of the movie.
//Return the bit rate of the movie or audio file in bits per second.
//Return the bit rate of the video in bits per second.
//Return the audio bit rate of the media file in bits per second.
//Return the audio sample rate of the media file in bits per second.
//Return the current frame index.
//Return the name of the video codec used to encode this movie as a string.
//Return the name of the audio codec used to encode this movie as a string.
//Return the number of audio channels in this movie as an integer.
//Return boolean value indicating whether the movie has an audio stream.
//Return boolean value indicating whether the movie has a video stream.
//Returns a frame from the movie as an ffmpeg_frame object. 
//Returns false if the frame was not found.
//framenumber - Frame from the movie to return. 
//If no framenumber is specified, returns the next frame of the movie.
$movie->getFrame([Integer framenumber])	
//Returns the next key frame from the movie as an ffmpeg_frame object. 
//Returns false if the frame was not found.

No nosso caso, os únicos métodos que vão nos interessar seram: getFrameRate, getDuration, getFrameCount, getFrameHeight , getFrameWidth e getFrame.

No início do seu script, coloque esta linha só por segurança:

if ( ! extension_loaded ( 'ffmpeg' ) ) exit ( 'ffmpeg não foi carregado!' );

Para receber as informações do vídeo dentro do seu arquivo PHP você precisa utilizar a classe ffmpeg_movie do ffmpeg-php e passar como parametro o caminho do vídeo que você quer manipular.

// instancia a classe ffmpeg_movie para pegarmos as informações que queremos o vídeo
$movie = new ffmpeg_movie($movie_file);
// pegamos a duranção do video em segundos
$duration = round ( $movie->getDuration() , 0 ); 
// recebemos o número de frames do vídeo
$totalFrames = $movie->getFrameCount();
// recebemos a altura do vídeo em pixels
$height = $movie->getFrameHeight ();
// recebemos a largura do vídeo em pixels
$width = $movie->getFrameWidth ();

Recebendo o frame do vídeo e salvando

Agora que já temos as informações do vídeo, podemos capturar a miniatura de um determinado frame do vídeo e salva-la em nosso HD. Vamos utilizar outra classe do ffmpeg-php chamada ffmpeg_frame e utilizarmos a função toGDImage para convertermos o frame para uma imagem GD.

Para escolhermos o frame podemos utilizar algumas técnicas:

Miniatura de um segundo especifico:

$thumbnailOf = $movie->getFrameRate() * 5;

Miniatura do meio do vídeo:

$thumbnailOf = round ( $movie->getFrameCount() / 2 );

Neste exemplo vou pegar fazer um calculo para receber um frame do meio do vídeo e salvar no HD.

// precisamos criar uma imagem GD para o ffmpeg-php trabalhar nela
$image = imagecreatetruecolor ( $width , $height ) ;
// criamos a instancia do frame com a classe ffmpeg_frame
$frame = new ffmpeg_frame ( $image );
// escolhemos o frame que queremos salvar como jpeg
$thumbnailOf = (int) round ($movie->getFrameCount() / 2.5);
// recebe o frame
$frame = $movie->getFrame ( $thumbnailOf );
// converte para uma imagem GD
$image = $frame->toGDImage ();
//salva no HD.
imagejpeg($image, $movie_file.'.jpg', 100);

Pronto! Agora não tem desculpa. Vocês já sabem capiturar o frame de um video e salvar uma miniatura dele.

Redimencionando o frame do video

Este capitulo é um bonus. Vocês também podem salvar um frame especifico do video como jpeg e redimenciona-lo antes e salvar no HD. A função resize() da classe ffmpeg_frame faz isso para gente:

$frame->resize(Integer width, Integer height [, Integer crop_top [, Integer crop_bottom [, Integer crop_left [, Integer crop_right ]]]])

Utilizando o mesmo código acima, acrescentando somente uma linha:

// colei esta linha somente como referencia
$frame = $movie->getFrame ( $thumbnailOf ); 
// redimenciona o frame para 200 de lagura por 100 de algura.
$frame->resize ( 200, 100 );

Podemos também, redimencionar esta imagem e fazer um crop nela:

// colei esta linha somente como referencia
$frame = $movie->getFrame ( $thumbnailOf );
// redimencionamos o frame para 200x100 e mas com o acrescimo de um crop de 30x30x30x30.
$frame->resize ( 200, 100, 30, 30, 30, 30 );

É isso aí!

Maiores informações, na documentação oficial do ffmpeg-php.


Posts Relacionados:

Mais um Zend Certified Engineer

Mais uma etapa da vida concluída. No dia 19 de julho, ao meio dia, eu me tornei mais um PHP5 Zend Certified Engineer. Não vou te enganar não, não foi fácil. A prova tem muita pegadinha o inglês da prova é bem tecnico e você precisa de muita calma e paciência para fazer a prova.

Após “aquele” cagaço de clicar em “Finish Exam”, eu fechei os olhos, contei até 10. Ao abrir os olhos, vejo a notícia no monitor:


#nerdpride. Enfim, acho que vocês já estão de saco cheio de tanto que eu falo desta certificação aqui no blog. O post é só para comunicar que eu consegui. Afinal, começou!, termina!. Muita gente ficou torcendo por mim deste o começo e nada mais justo do que vir até aqui e anunciar a conquista da mesma forma que eu anunciei a luta.

Obrigado à todos os que me ajudaram nos tempos de estudo e todos os que torceram por mim.

😀 Até o próximo post 😀

Posts Relacionados:

Falta pouco para a ZCE

Olá pessoal, este é um post de muita alegria (hehe).

Faz 4 semanas que eu estou na luta para me tornar um Zend Certified Engineer. Dos 10 simulados que eu comprei no zend shop este é o resultado no meu quinto simulado. Confesso que no começo apanhei um pouco. Tem muita coisa que o exame cobra que é decoreba. Só o dia-a-dia com PHP para te ensinar certas coisas.

No meu quinto simulado esta é a primeira vez que eu tiro excellent em todos os tópicos do exame. Agradeço a todos os que me ajudaram nesta fase de estudo, principalmente Fernando Mantoan, Felipe Ribeiro e Jaydson Gomes. – Vocês são foda!

Vou divulgar aqui para vocês os materiais que me ajudaram para a prova da ZCE:

  1. ZEND PHP5 Certification Study Guide (PDF)
  2. Passing the Zend php 5 certification exam
  3. Strings And Regular Expressions
  4. Streams And Network
  5. XML & Web Service
  6. Web Programming & Web Features
  7. Database & SQL
  8. Security
  9. PHP 4 & PHP 5
  10. Object Oriented Programming in PHP 5
  11. Object Oriented Programming: Design & Theory
  12. Zend PHP5 certification Exam study review 10: Supplementary I
  13. Zend PHP5 certification Exam study review 10: Supplementary II
  14. Zend PHP5 certification Exam study review 10: Supplementary III

Posts Relacionados:

Zend Certified Engineer, Vamos?

Arrumei dinheiro. Tomei vergonha na cara. Certificações é sempre um assunto que gera bastante polêmica. Sempre que falamos sobre o assunto, tem sempre alguém que declara guerra e não para de falar sem parar os motivos pelos quais ele despreza as certificações. Não tiro a razão de ninguém.

Mas eu tenho um pensamento que vocês deveriam refletir. Não falo isso generalizando as certificações, estou falando da ZCE.

Minha mensagem é especificamente para as pessoas que amam o PHP assim como eu. Pessoas que realmente levam a sua filosofia e a sua comunidade a sério. Se você não faz a certificação por que tem raiva do mundo, então faça pelo PHP. Quanto mais de nós, profissionais, nos comprometermos com o meio em que trabalhamos, mais informal este mercado deixa de ser e mais ele passa a ser levado a sério.

Eu particularmente quero tirar esta certificação para me testar, ver como eu estou (oficialmente) na linguagem e claro é uma boa oportunidade para aprimorar os conhecimentos, estudar mais e quem sabe isso possa me trazer sorte (rs).

Tirar a certificação este ano não estava nos meus planos. Este ano era para eu ter iniciado a minha pós-graduação em Engenharia de Software, porém, não estou tendo condições financeiras de pagar o curso este ano.  Sem grana, resolvi adiantar a certificação e inverter as metas.

Este ano “vou” me certificar pela Zend. Já comprei o Zend PHP 5 Certification Bundle, recebi todo o material e agora é só cair de cara nos livros e me preparar para o exame final que pretendo fazer daqui um ou dois meses.

Se você tem interesse em se certificar vai aqui algumas informações que podem te acrescentar algo:

  • Você pode pagar a certificação com qualquer cartão de crédio internacional Visa/MasterCard, PayPal ou Transferência Bancária.
  • Material, simulados e a prova final é em inglês.
  • Os simulados são dados pela php|architect.
  • Os simulados, em teoria são mais difíceis do que a prova oficial.
  • Se você vai bem nos simulados, você vai bem no exame.
  • São 80 questões e você tem 90 minutos para responder (simulado e exame final).
  • O investimento total sai por 165,00 dolares.
  • A prova é bem detalhista. Se você pensa que a parte chata (bitwise operators, manipulação de números exponenciais, hexadecimais e octais por exemplo) não cai, você está enganado.
  • Prepare-se para decorar nome de funções e suas derivadas.
  • Os simulados são online.
  • O exame é aplicado somente em centros habilitados pela Zend.
  • Existem milhares centros espalhados pelo globo (inclusive no brasil).
  • Se você falhar no exame final, não se preocupe, a Zend oferece descontos para uma próxima prova (que eu pretendo não descobrir qual é).

Me desejem sorte 🙂


Posts Relacionados:

PHP Conference Brasil 2010

O PHPSP está responsável pelo conteúdo do evento, por isso, disponibilizamos a todos um lugar onde qualquer pessoa pode se registrar e cadastrar seus palestras de maneira simples, rápida e fácil. Tentamos simplificar todo o processo da melhor forma possível, mas se você tiver alguma crítica/sugestão ficaremos felizes em poder atendê-las  se possível.

Mas o que é a chamada de trabalhos?

A chamada de trabalhos é um período em que todos que estiverem interessados em palestrar no evento, possam enviar suas propostas de palestra. Você não precisa ser um expert, ou ter palestrado em algum evento. Como o público da PHP Conference Brasil é grande, tenha certeza de que o assunto que você se sente seguro para abordar, será apreciado pelas pessoas. Então não se acanhe, envie sua proposta de palestra! Seja ela uma abordagem simples para quem está começando, um caso de uso da linguagem ou alguma nova ferramenta. Nos envie! Você não tem nada a perder, muito pelo contrário!

O que eu ganho caso minha palestra seja escolhida?

Você tem uma entrada gratuita para o evento, nos dois dias de palestras e caso sua palestra seja escolhida e você esteja em outros estados; a organização do evento custeia sua passagem e hospedagem. Existe jeito melhor de ir a um evento?!

Como serão escolhidas as palestras?

Simples: serão escolhidas por vocês! Ao fecharmos a chamada de trabalho ninguém mais vai poder enviar palestras, aí começamos um período de avaliação, e vocês serão os avaliadores. Ninguém vai saber quem vai dar a palestra, o objeto de avaliação será somente a palestra e no evento entrarão as palestras que contiverem as melhores avaliações, ou seja: as palestras que vocês querem ver!

Ok, quero enviar minhas palestras !

Sim, envie mais de uma! Quanto mais palestras você enviar, mais chances de participar do evento!

Para enviar sua palestra simplesmente acesse e se cadastre:


Posts Relacionados:

5º Seminário PHP

Em sua 5ª edição temos um evento voltado tanto para Desenvolvedores como para Coordenadores e Gerentes. O evento começa as 9:00, no mesmo local da 4ª edição, Century Flat Paulista – R. Teixeira da Silva, 647 – Paraíso.

Público Alvo: Desenvolvedores PHP, sobretudo aqueles que procuram se profissionalizar, Coordenadores e Gerente de Projetos.

Objetivo: Incentivar a formação de pessoas para o mercado corporativo, a fim de construir aplicações e portais mais sólidos e escaláveis de forma eficiente.

Com 5 palestras e 4 palestrantes bem conhecidos na comunidade, abordaremos temas atuais e o que eles podem ajudar no desenvolvimento de aplicação estáveis e de simple manutenção.

Pela primeira vez, Cal Evans no Brasil!

Em uma palestra focada em gerentes de desenvolvimento, Cal Evans evangelista PHP,  fala sobre como um gerente pode aprender com a comunidade Open Source e motivar os desenvolvedores possibilitando novos desafios, crescimento e inovação! Além disso, Cal tomará mais uma vez o pódio focando nos desenvolvedores e falando sobre Flash Builder4 e PHP, em uma sessão de live coding!

Rafael Dohms foca as vantagens de Test Driven Development e porque isso é bom a longo e curto prazo e como isso pode trazer produtividade e confiança ao seu time.

Guilherme Blanco mostra a versão 2.0 do Doctrine, o maior ORM de PHP. Usando todas as vantagens do PHP 5.3 esta nova versão tem um grande potencial para aumentar ainda mais a produtividade de seu time.

Augusto Pascutti irá falar sobre os bancos de dados não relacionais (NoSQL) que estão surgindo. Suas aplicações, como funcionam e o suporte deles nas versões atuais do PHP.

Todas as palestras possuem uma mescla de gerência e desenvolvimento, sendo assim palestras muito úteis para gerentes que queiram levar seu time ao próximo nível, de qualidade e agilidade, ou para desenvolvedores que queira facilitar seu trabalho do dia a dia e trazer ainda mais produtividade.

Após as palestras teremos uma mesa redonda para discutir os mais diversos assunto e depois, para os que aguentarem, teremos o #phpinga para jogar papo fora e, claro, falar de PHP de um jeito mais descontraído.

Já se inscreveu? Não esqueça de se cadastrar no para comentar as palestras e obter os slides posteriormente.

Increva-se já pois as vagas são limitadas

Posts Relacionados: