A maneira mais fácil de obter o Zend Framework junto com uma pilha PHP completa é através da instalação do Zend Server. O Zend Server tem instaladores nativos para Mac OSX, Windows, Fedora Core e Ubuntu, bem como um pacote de instalação universal compatível com a maioria das distribuições Linux.

Depois que você tiver instalado o Zend Server, os arquivos Framework podem ser encontrados em /usr/local/zend/share/ZendFramework no Mac OSX e Linux, e em C:\Program Files\Zend\ZendServer\share\ZendFramework no Windows. O include_path já estará configurado para incluir o Zend Framework.

Alternadamente, você pode fazer o Download da última versão do Zend Framework e extrair os conteúdos; faça nota de onde você fez isso.

Opcionalmente, você pode adicionar o caminho do arquivo para o subdiretório library/ para a configuração include_path do seu php.ini.

É isso! O Zend Framework agora está instalado e pronto para uso.

Abra o terminal (no Windows, Iniciar -> Executar, e então use cmd). Vá até o diretório onde você gostaria de iniciar um projeto. Depois, use o caminho para o script apropriado, e execute um dos seguintes:

% zf create project quickstart

Executando este comando, será criada a estrutura básica do seu site, incluindo seus controladores e visualizações iniciais. A árvore parece com o seguinte:

quickstart
|-- application
|   |-- Bootstrap.php
|   |-- configs
|   |   `-- application.ini
|   |-- controllers
|   |   |-- ErrorController.php
|   |   `-- IndexController.php
|   |-- models
|   `-- views
|       |-- helpers
|       `-- scripts
|           |-- error
|           |   `-- error.phtml
|           `-- index
|               `-- index.phtml
|-- library
|-- public
|   |-- .htaccess
|   `-- index.php
`-- tests
    |-- application
    |   `-- bootstrap.php
    |-- library
    |   `-- bootstrap.php
    `-- phpunit.xml

Até este ponto, se você não adicionou o Zend Framework para o seu include_path, nós recomendamos também copiar ou criar um link simbólico em seu diretório library/. Em qualquer caso, você vai querer copiar recursivamente ou simbolizar o diretório library/Zend/ da sua instalação Zend Framework no diretório library/ do seu projeto. Nos sistemas baseados em Unix, que pareceriam como um dos seguintes:

# Symlink:
% cd library; ln -s path/to/ZendFramework/library/Zend .

# Copy:
% cd library; cp -r path/to/ZendFramework/library/Zend .

Nos sistemas Windows, pode ser mais fácil fazer isso do Explorer.

Agora que o projeto está criado, os artefatos principais para iniciar o entendimento são a inicialização da aplicação, configuração, controladores de ação e vizualizações.

A classe Inicialização da Aplicação define quais recursos e componentes inicializar. Por padrão, o Controlador Frontal do Zend Framework é inicializado, e ele usa o application/controllers/ como diretório padrão o qual procura por controladores de ação (mais sobre isso mais tarde). A classe parece com o seguinte:

// application/Bootstrap.php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}

As you can see, not much is necessary to begin with. Como você pode ver, não é necessário muito para iniciar.

Enquanto o Zend Framework é em si configuração, muitas vezes você precisa configurar sua aplicação. A configuração padrão está localizada em application/configs/application.ini, e contém algumas diretrizes básicas para configurar seu ambiente PHP (por exemplo, transformar relatório de erros dentro e fora), indicando o caminho para sua classe inicialização da aplicação (tão bem como sua classe nome), e o caminho para seus controladores de ação. Isso parece com o seguinte:

; application/configs/application.ini

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Diversas coisas sobre este arquivo devem ser notadas. Primeiro, quando usar configuração de estilo INI, você pode referenciar constantes diretamente e expandi-las; APPLICATION_PATH é na verdade uma constante. Adicionalmente note que há várias seções definidas: produção, encenação, teste, e desenvolvimento. As últimas três herdam configurações do ambiente "produção". Este é um modo eficiente de organizar configurações para assegurar que as configurações apropriadas são válidas em cada estágio do desenvolvimento da aplicação.

Your application's action controllers contain your application workflow, and do the work of mapping your requests to the appropriate models and views.

An action controller should have one or more methods ending in "Action"; these methods may then be requested via the web. By default, Zend Framework URLs follow the schema /controller/action, where "controller" maps to the action controller name (minus the "Controller" suffix) and "action" maps to an action method (minus the "Action" suffix).

Typically, you always need an IndexController, which is a fallback controller and which also serves the home page of the site, and an ErrorController, which is used to indicate things such as HTTP 404 errors (controller or action not found) and HTTP 500 errors (application errors).

The default IndexController is as follows:

// application/controllers/IndexController.php

class IndexController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }

    public function indexAction()
    {
        // action body
    }
}

And the default ErrorController is as follows:

// application/controllers/ErrorController.php

class ErrorController extends Zend_Controller_Action
{

    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:

                // 404 error -- controller or action not found
                $this->getResponse()->setHttpResponseCode(404);
                $this->view->message = 'Page not found';
                break;
            default:
                // application error
                $this->getResponse()->setHttpResponseCode(500);
                $this->view->message = 'Application error';
                break;
        }

        $this->view->exception = $errors->exception;
        $this->view->request   = $errors->request;
    }
}

You'll note that (1) the IndexController contains no real code, and (2) the ErrorController makes reference to a "view" property. That leads nicely into our next subject.

Views in Zend Framework are written in plain old PHP. View scripts are placed in application/views/scripts/, where they are further categorized using the controller names. In our case, we have an IndexController and an ErrorController, and thus we have corresponding index/ and error/ subdirectories within our view scripts directory. Within these subdirectories, you will then find and create view scripts that correspond to each controller action exposed; in the default case, we thus have the view scripts index/index.phtml and error/error.phtml.

View scripts may contain any markup you want, and use the <?php opening tag and ?> closing tag to insert PHP directives.

The following is what we install by default for the index/index.phtml view script:

<!-- application/views/scripts/index/index.phtml -->
<style>

    a:link,
    a:visited
    {
        color: #0398CA;
    }

    span#zf-name
    {
        color: #91BE3F;
    }

    div#welcome
    {
        color: #FFFFFF;
        background-image: url(http://framework.zend.com/images/bkg_header.jpg);
        width:  600px;
        height: 400px;
        border: 2px solid #444444;
        overflow: hidden;
        text-align: center;
    }

    div#more-information
    {
        background-image: url(http://framework.zend.com/images/bkg_body-bottom.gif);
        height: 100%;
    }

</style>
<div id="welcome">
    <h1>Welcome to the <span id="zf-name">Zend Framework!</span><h1 />
    <h3>This is your project's main page<h3 />
    <div id="more-information">
        <p>
            <img src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />
        </p>

        <p>
            Helpful Links: <br />
            <a href="http://framework.zend.com/">Zend Framework Website</a> |
            <a href="http://framework.zend.com/manual/en/">Zend Framework
                Manual</a>
        </p>
    </div>
</div>

The error/error.phtml view script is slightly more interesting as it uses some PHP conditionals:

<!-- application/views/scripts/error/error.phtml -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>Zend Framework Default Application</title>
</head>
<body>
  <h1>An error occurred</h1>
  <h2><?php echo $this->message ?></h2>

  <?php if ('development' == $this->env): ?>

  <h3>Exception information:</h3>
  <p>
      <b>Message:</b> <?php echo $this->exception->getMessage() ?>
  </p>

  <h3>Stack trace:</h3>
  <pre><?php echo $this->exception->getTraceAsString() ?>
  </pre>

  <h3>Request Parameters:</h3>
  <pre><?php echo var_export($this->request->getParams(), 1) ?>
  </pre>
  <?php endif ?>

</body>
</html>

For purposes of this quick start, we will assume you are using the Apache web server. Zend Framework works perfectly well with other web servers -- including Microsoft Internet Information Server, lighttpd, nginx, and more -- but most developers should be famililar with Apache at the minimum, and it provides an easy introduction to Zend Framework's directory structure and rewrite capabilities.

To create your vhost, you need to know the location of your httpd.conf file, and potentially where other configuration files are located. Some common locations:

Within your httpd.conf (or httpd-vhosts.conf on some systems), you will need to do two things. First, ensure that the NameVirtualHost is defined; typically, you will set it to a value of "*:80". Second, define a virtual host:

<VirtualHost *:80>
    ServerName quickstart.local
    DocumentRoot /path/to/quickstart/public

    SetEnv APPLICATION_ENV "development"

    <Directory /path/to/quickstart/public>
        DirectoryIndex index.php
        AllowOverride All
        Order allow,deny
        Allow from all
    </Directory>
</VirtualHost>

There are several things to note. First, note that the DocumentRoot setting specifies the public subdirectory of our project; this means that only files under that directory can ever be served directly by the server. Second, note the AllowOverride, Order, and Allow directives; these are to allow us to use htacess files within our project. During development, this is a good practice, as it prevents the need to constantly restart the web server as you make changes to your site directives; however, in production, you should likely push the content of your htaccess file into your server configuration and disable this. Third, note the SetEnv directive. What we are doing here is setting an environment variable for your virtual host; this variable will be picked up in the index.php and used to set the APPLICATION_ENV constant for our Zend Framework application. In production, you can omit this directive (in which case it will default to the value "production") or set it explicitly to "production".

Finally, you will need to add an entry in your hosts file corresponding to the value you place in your ServerName directive. On *nix-like systems, this is usually /etc/hosts; on Windows, you'll typically find it in C:\WINDOWS\system32\drivers\etc. Regardless of the system, the entry will look like the following:

127.0.0.1 quickstart.local

Start your webserver (or restart it), and you should be ready to go.

At this point, you should be able to fire up your initial Zend Framework application. Point your browser to the server name you configured in the previous section; you should be able to see a welcome page at this point.