<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--
Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
-->
<html>
   <head>
      <title>Instalando e configurando PHP, Apache e MySQL para desenvolvimento de PHP em Windows</title>
     <meta name="KEYWORDS" content="NETBEANS, PHP, GUIDE, USER, DOCUMENTATION, XAMPP, MYSQL, APACHE">
      <meta name="DESCRIPTION" content="This document describes how to install and configure PHP, Apache, and MySQL for PHP development in the NetBeans IDE under Windows" >
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <link rel="stylesheet" type="text/css" href="../../../netbeans.css" media="screen"></head>
   <body>
<h1>Configurando o Ambiente de Desenvolvimento de PHP no Windows</h1>
<p>Este tutorial mostra duas formas de configurar o ambiente de desenvolvimento de PHP no sistema operacional Windows. A primeira e mais conveniente é instalar e configurar um pacote AMP (<strong>A</strong>pache, <strong>M</strong>ySQL, <strong>P</strong>HP). Este tutorial mostra como instalar o pacote XAMPP. A segunda maneira, é instalar e configurar cada componente separadamente.</p>
<!--
<div>
  <p>  -->
<!--    <!-- #BeginDate format:Am1-->
<!-- July 29, 2008 #EndDate -->
<!-- </p>
</div> -->
<p><strong>Conteúdo</strong></p>
<img alt="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0" class="stamp" src="../../../images_www/articles/73/netbeans-stamp-80-74-73.png" title="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0">
<ul>
<!--<li><a href="#requiredSoftware">Required Software</a></li> -->
<li><a href="#XAMPP">Utilizando um Pacote AMP</a>
  <ul>
<li><a href="#installConfigureXAMPP">Instalando e Configurando o Pacote XAMPP</a></li>
<li><a href="#checkXAMPPInstallation">Verificando a Instalação do XAMPP</a></li>
<li><a href="#installAndEnableXDebug">Instalando e Ativando o Depurador XDebug</a></li>
</ul>
</li>
<li><a href="#installComponentsSeparately">Instalando os Componentes Separadamente</a>
  <ul>
<li><a href="#installApacheComponent">Servidor HTTP Apache</a></li>
<li><a href="#installPHPEngine">Mecanismo PHP</a></li> 
<li><a href="#installMySQL">Servidor de Banco de Dados MySQL</a></li>
<li><a href="#installXDebug">XDebug</a></li>
<li><a href="#settingUpEnvironment">Configurando o Ambiente</a></li> 
</ul></li></ul>
<p><b>Para seguir este tutorial, são necessários os recursos e o software a seguir.</b></p>

  <table>
    <tbody>
      <tr>
        <th class="tblheader" scope="col">Software ou Recurso</th>
        <th class="tblheader" scope="col">Versão Necessária</th>
      </tr>
      <tr>
        <td class="tbltd1"><a href="https://netbeans.org/downloads/index.html" target="_blank">NetBeans IDE</a></td>
        <td class="tbltd1">Pacote de download do PHP</td>
      </tr>
      <tr>
        <td class="tbltd1">Um mecanismo PHP</td>
        <td class="tbltd1">Versão 5. Incluído no <a href="http://www.apachefriends.org/en/xampp-windows.html" target="_blank">XAMPP-Windows</a>. 
        </tr>
      <tr>
        <td class="tbltd1">Um servidor web</td>
        <td>É recomendado o <a href="http://httpd.apache.org/download.cgi" target="_blank">Apache HTTP Server 2.2</a>.<br> Incluído no XAMPP do Windows.</td>
      </tr>
      <tr>
        <td class="tbltd1">Um servidor de banco de dados</td>
        <td><a href="http://dev.mysql.com/downloads/mysql/5.1.html" target="_blank">MySQL Server 5.0</a> é recomendado.<br> Incluído no XAMPP do Windows.</td>
      </tr>
      <tr>
        <td class="tbltd1">Um depurador do PHP (opcional)</td>
        <td><a href="http://www.xdebug.org" target="_blank">XDebug 2.0 ou superior.</a><br /></td>
      </tr>
    </tbody>
  </table>
<p class="notes">Geralmente, o desenvolvimento e a depuração são realizados em um servidor web local, enquanto o ambiente de produção está localizado em um servidor web remoto. A configuração de um servidor web remoto é descrita em <a href="./remote-hosting-and-ftp-account.html"> Implantado uma Aplicação PHP em um Servidor Web Remoto com o NetBeans IDE</a>. Este tutorial ensina como configurar um servidor web local. O suporte a PHP pode ser adicionado a vários servidores web locais (IIS, Xitami e assim por diante), mas, em geral, o <a href="http://httpd.apache.org/download.cgi" target="_blank">servidor HTTP Apache</a> é usado. O servidor HTTP Apache está incluído no pacote AMP do XAMPP utilizado neste tutorial. Para obter informações sobre como instalar e configurar o servidor HTTP Apache standalone, clique <a href="http://httpd.apache.org/docs/2.2/install.html" target="_blank">aqui</a>. </p>
<h2><a name="requiredSoftware"></a>Software Necessário</h2>
<p>Para criar, executar e depurar os projetos PHP, você precisa do seguinte software:</p>
<ul>
  <li>O NetBeans IDE para PHP. Os downloads estão disponíveis <a href="https://netbeans.org/downloads/index.html" target="_blank">aqui</a>. </li>
  <li>Um servidor Web. Geralmente, o desenvolvimento e a depuração são realizados em um servidor Web local, enquanto o ambiente de produção está localizado em um servidor Web remoto. A versão atual permite a utilização de um servidor local. A utilização de um servidor remoto com acesso a FTP terá suporte em versões futuras. O suporte a PHP pode ser adicionado a vários servidores Web (IIS, Xitami e assim por diante), mas, em geral, o <a href="http://httpd.apache.org/download.cgi" target="_blank">Servidor HTTP Apache</a> é utilizado. Clique <a href="http://httpd.apache.org/docs/2.2/install.html" target="_blank">aqui</a> para obter informações sobre como instalar e configurar o Apache 2.2. <a href="http://httpd.apache.org/docs/2.2/install.html" target="_blank"></a></li>
</ul>
<ul>
  <li>O mecanismo PHP. A versão com suporte é o PHP5. Os downloads estão disponíveis <a href="http://www.php.net/downloads.php" target="_blank">aqui</a>. </li>
  <li>O depurador do PHP. O NetBeans IDE para PHP permite que você utilize o <a href="http://www.xdebug.org" target="_blank">XDebug</a>, mas a utilização de um depurador é opcional. A versão recomendada é XDebug 2.0 ou superior, pois é compatível com PHP5. </li>
  <li>Um servidor de banco de dados. Você pode utilizar vários servidores de bancos de dados, embora um dos mais populares seja o MySQL. Os downloads estão disponíveis <a href="http://dev.mysql.com/downloads/mysql/5.1.html" target="_blank">aqui</a>. <br> <strong>Observação:</strong> a versão recomendada do produto é MySQL Server 5.0. Os documentos fornecidos descrevem o trabalho com essa versão.</li>
</ul>
<p>Depois da instalação, você precisa configurar o ambiente de forma que todos os componentes de software funcionem bem juntos. </p>
<p>Você pode utilizar um <a href="#XAMPP"> Pacote</a> que contenha o software necessário ou <a href="#installComponentsSeparately">instalar cada componente separadamente</a>. </p>
<h2><a id="XAMPP" name="XAMPP"></a>Utilizando um Pacote AMP</h2>
<p>Para que todas as definições de configuração do mecanismo PHP, do servidor HTTP Apache e do servidor de banco de dados MySQL sejam especificadas automaticamente, utilize o pacote AMP. Este tutorial fornece instruções somente para o pacote <a href="http://www.apachefriends.org/en/xampp-windows.html" target="_blank">XAMPP-Windows</a>. Para obter ajuda com o pacote WAMP, consulte a <a href="http://wiki.netbeans.org/HowToConfigureXDebug" target="_blank">wiki do XDebug do NetBeans</a>.</p>
<h3><a name="installConfigureXAMPP"></a>Instalando e Configurando o Pacote XAMPP</h3>
<p>A seção descreve como fazer download, instalar e configurar o pacote XAMPP. </p>
<p class="alert"><strong>Advertência:</strong> NÃO use XAMPP 1.7.0. Há problemas significativos com o XDebug nessa versão. Use a versão 1.7.1 ou superior, em que esses problemas foram corrigidos.</p>
<p class="notes"><strong>Observação: </strong>a partir do XAMPP 1.7.2, o XAMPP vem com PHP 5.3, não PHP 5.2.x. O NetBeans IDE para PHP, versão 6.7.x, não oferece suporte às novas funções do PHP 5.3. O NetBeans IDE para PHP 6.8, atualmente disponível como construtor de desenvolvimento, oferece suporte total ao PHP 5.3. Observe também que a instalação do Xdebug difere entre o PHP 5.2.x e o PHP 5.3.</p>
<ol>
  <li>faça download do pacote de instalação do <a href="http://www.apachefriends.org/en/xampp-windows.html" target="_blank">XAMPP</a>. (O XAMPP Lite não inclui o XDebug.)</li>
  <li>Quando o download tiver sido concluído, execute o arquivo <tt> .exe </tt>. 
    <p class="alert">No Microsoft Vista, a funcionalidade Controle de Acesso do Usuário impede que o instalador do PHP atualize a configuração do httpd Apache. Desative o UAC ao instalar o XAMPP. Consulte o <a href="http://support.microsoft.com/kb/922708" target="_blank">Suporte da Microsoft</a> para obter mais informações.<br>
    </p>
  </li>
  <li>Você tem a opção de instalar o servidor Apache e o servidor de banco de dados MySQL como serviços. Se instalar o Servidor Apache e o MySQL como serviços, não terá que iniciá-los manualmente pelo Painel de Controle do XAMPP. Observe que você tem a opção de instalar ou desinstalar esses serviços no <a href="#xamppConstolPanel">Painel de Controle do XAMPP</a>.</li>
  <li>Se estiver utilizando o arquivo compactado autoextraível, depois de ele ter sido extraído, execute o arquivo <tt>setup-xampp.bat</tt> para configurar os componentes do pacote. (O instalador do XAMPP executa automaticamente o arquivo).</li>
  <li><a id="xamppConstolPanel" name="xamppConstolPanel"></a>Após configurar, abra o Painel de Controle do XAMPP. (Você pode abri-lo manualmente executando o arquivo <tt>XAMPP_HOME/xampp-control.exe</tt> ou a partir do ícone Painel de Controle do Xampp, que é automaticamente colocado em sua área de trabalho.) Ao abrir o Painel de Controle do XAMPP, observe que os módulos instalados como serviços já estão em execução.
    <p class="alert"><b>Advertência: </b>algumas vezes, no Windows Vista, o <tt>xampp-control.exe</tt> não será executado. No lugar dele, você pode executar o <tt>xampp-start.exe</tt>.</p>
    <p class="alert"><b>Advertência: </b>o <tt>arquivo winmysqladmin.exe</tt>, que é iniciado pelo botão Admin para o MySQL, não funciona. Aparece uma sequência de mensagens de erro, que pode ser parada somente de forma manual, pelo encerramento do processo <tt>winmysqladmin</tt>. Você também não pode acionar o <tt>winmysqladmin.exe</tt> a partir da linha de comandos. Consulte <a href="http://bugs.xampp.org/view.php?id=71" target="_blank">http://bugs.xampp.org/view.php?id=71</a>.</p>
  <img alt="Painel de Controle do XAMMP" class="margin-around" height="361" src="../../../images_www/articles/72/php/configure-php-environment-windows/xampp-control-panel.png" width="454"> </li>
  <li>As caixas de seleção Svc indicam que um módulo está instalado como um serviço do Windows e será automaticamente iniciado na inicialização do sistema. Você pode instalar ou desinstalar os serviços do Windows marcando ou desmarcando a caixa de seleção Svc. A desinstalação de um serviço do Windows não desinstala o módulo, mas requer a inicialização manual do módulo. O painel de controle do XAMPP inclui botões para parar e iniciar módulos e para abrir seus consoles de administração.<br>
  </li>
  </ol>
<h3><a name="checkXAMPPInstallation"></a>Verificando a Instalação do XAMPP </h3>
<ol>
<li>Execute o browser e digite o seguinte URL: <tt>http://localhost</tt>. A página de boas-vindas do XAMPP será aberta:<br> <img alt="A página de boas-vindas do XAMPP indica que o Apache está sendo executado" border="1" class="margin-around" src="../../../images_www/articles/72/php/configure-php-environment-windows/xampp-welcome-page.png">
</li>
<li>Para garantir que os servidores Apache e MySQL tenham sido instalados como serviços do sistema, reinicie o sistema operacional, execute o browser e digite o URL <tt>http://localhost</tt> novamente. A página de boas-vindas do XAMPP será aberta. Observe se a página de boas-vindas do XAMPP inclui um menu na margem esquerda, por meio do qual você pode verificar o status dos componentes do XAMPP e executar o <tt>phpinfo()</tt>, entre outras funcionalidades úteis. O <tt>phpinfo()</tt> retornará uma tela com informações de configuração sobre os componentes do XAMPP. <br><img alt="Tabela de informações de configuração retornadas pelo phpinfo()" class="margin-around" src="../../../images_www/articles/72/php/configure-php-environment-windows/xampp-phpinfo.png" /></li>
</ol>
<h3><a name="installAndEnableXDebug"></a>Instalando e Ativando o Depurador XDebug</h3>
<p>É necessário configurar a pilha PHP para utilizar o XDebug. Se você estiver utilizando o <a href="#xdebug-xampp-171">XAMPP 1.7.1</a>, incluído com o PHP 5.2.6, ou o <a href="#xdebug-xampp-172">XAMPP 1.7.2</a>, incluído com o PHP 5.3 o processo apresenta diferenças.</p>
<p class="alert">Muitos usuários têm tido dificuldades para fazer com que o XDebug funcione em seus sistemas. Consulte a <a href="http://wiki.netbeans.org/HowToConfigureXDebug" target="_blank">nossa wiki</a> e o <a href="http://forums.netbeans.org/viewforum.php?f=13&sid=5b63e6774fe7859b5edd35b1192d8efd" target="_blank">Fórum de Usuários do Editor PHP do NetBeans</a> para obter ajuda.</p>

<div class="indent">
    <h4 id="xdebug-xampp-171">XDebug no XAMPP 1.7.1 (PHP 5.2)</h4>
<p>É necessário fazer download do XDebug, colocar o arquivo .dll no diretório das extensões php e configurar php.ini para que localize e utilize esse arquivo.</p>
<ol>
<li>Faça download do <em>thread-safe</em> <a href="http://www.xdebug.org/download.php" target="_blank">XDebug</a> mais recente compatível com sua versão do PHP. Os links para download estão listados em Releases. Copie o arquivo <tt>.dll</tt> para seu diretório <tt>XAMP_HOME/php/ext</tt>. (<tt>XAMPP_HOME</tt> se refere ao seu diretório de instalação do XAMPP ou do XAMPP Lite, como <tt>C:\Arquivos de Programas\xampp</tt> ou <tt>C:\xampplite</tt>.)</li>
<li>Localize e abra o arquivo <tt>php.ini</tt> ativo para seu XAMPP. Ele está localizado por default no diretório<tt> XAMPP_HOME/apache/bin</tt>. Confirme qual arquivo <tt>php.ini</tt> está ativo executando <tt>phpinfo()</tt> e procurando o Arquivo de Configuração Carregado.</li>
<li>Como o otimizador Zend bloqueia o XDebug, é necessário desativar o otimizador Zend. No arquivo <tt>php.ini </tt>ativo, localize as linhas a seguir e as delete ou as marque como comentários (Para estar seguro, procure e comente todas as propriedades relacionadas ao Zend):
  <pre class="examplecode">
[Zend]
;zend_extension_ts = "C:\Program Files\xampp\php\zendOptimizer\lib\ZendExtensionManager.dll"
;zend_extension_manager.optimizer_ts = "C:\Program Files\xampplite\php\zendOptimizer\lib\Optimizer"
;zend_optimizer.enable_loader = 0
;zend_optimizer.optimization_level=15
;zend_optimizer.license_path =
</pre>
</li>
<li>Para anexar<a id="attachXDebug" name="attachXDebug"></a> XDebug ao mecanismo PHP, remova o comentário das linhas a seguir nos arquivos <tt>php.ini</tt> (diretamente abaixo da seção [Zend], adicione-os caso não estejam presentes). Algumas notas adicionais foram acrescentadas.
  <pre class="examplecode">[XDebug]<br>; Only Zend OR (!) XDebug
zend_extension_ts = &quot;./php/ext/php_xdebug&lt;-version-number&gt;.dll&quot;
; XAMPP and XAMPP Lite 1.7.0 and later come with a bundled xdebug at &lt;XAMPP_HOME&gt;/php/ext/php_xdebug.dll, without a version number.<br>xdebug.remote_enable=1<br>xdebug.remote_host=127.0.0.1<br>xdebug.remote_port=9000
; Port number must match debugger port number in NetBeans IDE Tools &gt; Options &gt; PHP<br>xdebug.remote_handler=dbgp<br>xdebug.profiler_enable=1<br>xdebug.profiler_output_dir=&quot;&lt;XAMPP_HOME&gt;\tmp&quot;<br>
  </pre>
  <p>Defina a propriedade <tt>xdebug.remote_enable</tt> como 1, não "true" ou qualquer outro valor.</p>
<p class="notes"><strong>Observação:</strong> certifique-se de que os caminhos especificados coincidam com o local dos arquivos correspondentes, conforme determinado durante a instalação.</p></li>
<li>Salve o <tt>php.ini</tt>.</li>
<li>Execute a <a href="#xamppConstolPanel">Aplicação Painel de Controle do XAMPP</a> e reinicie o servidor Apache. </li>
</ol>
Consulte <a href="http://wiki.netbeans.org/HowToConfigureXDebug" target="_blank">nosso wiki</a> e a <a href="http://www.xdebug.org/docs/install" target="_blank">documentação do XDebug</a> para obter mais informações sobre como configurar o XDebug.<br>
<h4 id="xdebug-xampp-172">Xdebug no XAMPP 1.7.2 (PHP 5.3)</h4>
<p>O XAMPP 1.7.2 está incluído com o arquivo .dll apropriado do Xdebug. Você só precisa configurar o <tt>php.ini</tt> para utilizar esse arquivo. Observe que todas as definições do Xdebug apresentam um texto explicativo.</p>
<ol>
  <li>Localize e abra o <tt>XAMPP_HOME\php\php.ini</tt> para edição. Trata-se do único arquivo <tt>php.ini</tt> no XAMPP 1.7.2.</li>
  <li>Localize e elimine o comentário da linha <tt>zend_extension = "XAMPP_HOME\php\ext\php_xdebug.dll"</tt>.</li>
  <li>Localize e elimine o comentário da linha <tt>xdebug.remote_host=localhost</tt>. Altere o valor da definição de <tt>localhost</tt> para <tt>127.0.0.1</tt>.</li>
  <li>Localize e elimine o comentário da linha <tt>xdebug.remote_enable=0</tt>. Altere de 0 para 1.</li>
  <li>Localize e elimine o comentário da linha <tt>xdebug.remote_handler="dbgp"</tt>.</li>
  <li>Localize e elimine o comentário da linha <tt>xdebug.remote_port= 9000</tt>.</li>
  <li>Salve o <tt>php.ini</tt>.</li>
  <li>Execute a <a href="#xamppConstolPanel">Aplicação Painel de Controle do XAMPP</a> e reinicie o servidor Apache. </li>
  </ol>
<p>Consulte <a href="http://wiki.netbeans.org/HowToConfigureXDebug" target="_blank">nosso wiki</a> e a <a href="http://www.xdebug.org/docs/install" target="_blank">documentação do XDebug</a> para obter mais informações sobre como configurar o XDebug.<br>
</p>
</div>
<h2><a id="installComponentsSeparately" name="installComponentsSeparately"></a>Instalando os Componentes Separadamente </h2>
<div class="indent">
<h3><a name="installApacheComponent"></a>Servidor HTTP Apache</h3>
<ol>
  <li>Faça download do <a href="http://httpd.apache.org/download.cgi" target="_blank">servidor HTTP Apache2</a>.</li>
  <li>Execute o arquivo de instalação <tt>.msi</tt>. O assistente de instalação é iniciado. Siga as instruções.
  <p class="alert">No Microsoft Vista, não instale o Servidor Apache na localização default, que é Arquivos de Programas. Todos os arquivos em Arquivos de Programas estão protegidos contra gravação.</p></li>
  <li>Quando a instalação tiver sido concluída, reinicie o servidor Apache. </li>
  <li>Para verificar se a instalação foi bem-sucedida, execute o browser e insira o seguinte URL:
    <pre class="examplecode">
  http://localhost/</pre> 
  A página de teste de boas-vindas do Apache será aberta: <br> <img alt="A página de teste do servidor web indica que o Apache está sendo executado" class="margin-around" src="../../../images_www/articles/72/php/configure-php-environment-windows/install-apache-it-works-port80.png"> </li>
</ol>
<h4>Solução de Problemas</h4>
Como default, o servidor Apache escuta a porta 80. Essa porta pode já estar sendo utilizada por outros serviços, por exemplo, o Skype. Para solucionar o problema, altere a porta que o servidor escuta: 
  <ol>
    <li>Abra o arquivo de configuração do servidor web Apache <tt>httpd.conf</tt>. Por default, o arquivo está localizado em <tt>C:\Arquivos de Programas\Apache Software Foundation\Apache&lt;version>\conf\</tt></li>
	<li>Localize a linha <tt>Listen 80</tt> e altere o número da porta, por exemplo, <tt>8080</tt>. Salve o arquivo.</li>
	<li>Reinicie o servidor web Apache.</li>
	<li>Para verificar se o servidor web está funcionando, execute o browser, insira o URL e especifique o número da porta de forma explícita: <tt>http://localhost:8080</tt></li>
</ol>
  <p>Você também pode interromper os processos que possivelmente ouvem a porta 80. No Gerenciador de Tarefas, selecione o nome de arquivo relevante e clique em Encerrar Processo.  </p>
  <p>Encontre mais informações sobre como instalar e configurar o servidor <a href="http://httpd.apache.org/docs/2.2/install.html" target="_blank">aqui</a>. </p>
  <h3><a name="installPHPEngine"></a>Mecanismo PHP</h3>
<ol>
  <li>Faça download do <a href="http://windows.php.net/download/" target="_blank">instalador binário do Windows</a> para a versão PHP5 de sua escolha.
      <p class="alert"><strong>Importante: </strong>se não houver um instalador disponível na versão do PHP que você deseja instalar, instale-o manualmente pelo arquivo .zip. Consulte <a href="http://php.net/manual/en/install.windows.manual.php" target="_blank">Etapas de Instrução Manual</a> na documentação do php.net.</p></li>
  <li>Quando o download estiver concluído, execute o arquivo de instalação <tt>.msi</tt>. O assistente de instalação é iniciado. </li>
  <li>No painel Diretório de Configuração do Apache, especifique o diretório onde o arquivo <tt>httpd.conf</tt> está localizado, a definição default é <tt>C:\Arquivos de Programas\Apache Software Foundation\Apache&lt;versão>\conf\</tt>. O processamento do PHP será ativado automaticamente.</li>
  <li>Se você desejar utilizar o servidor de banco de dados MySQL, escolha a opção de instalação Completa ou selecione os itens MySQL e MySQLi na lista Extensões. </li>
  <li>Depois que a instalação tiver sido concluída, reinicie o servidor Apache. </li>
  <li>Para verificar se o mecanismo PHP foi instalado com êxito e o processamento do PHP foi ativado na configuração do Apache:
    <ul>
  <li>Abra o Bloco de Notas ou outro editor de texto. Crie um arquivo e digite o texto a seguir:
  <pre class="examplecode">&lt;?php 
     echo &quot;PHP has been installed successfully!&quot;;
?&gt;</pre>  </li>
  <li>Salve o arquivo na pasta htdocs como <code>test.php</code>. O caminho padrão é <tt>C:\Program Files\Apache Software Foundation\Apache&lt;version>\htdocs\test.php</tt></li>
  <li>Execute o browser e digite o seguinte URL: <tt>http://localhost:&lt;porta>/test.php</tt>. A página a seguir será aberta:<br> <img alt="A página de teste do PHP indica que o mecanismo PHP está ativado" class="margin-around" src="../../../images_www/articles/72/php/configure-php-environment-windows/install-php-test.png">
   </li>
  </ul>
  </li>
</ol>
<h4>Solução de Problemas</h4>
Se a página não abrir:
<ol>
  <li>Reinicie o servidor Apache.</li>
  <li>Verifique se o arquivo de configuração do servidor Apache httpd.conf contém as seguintes linhas:
     <pre class="examplecode">
  AddType Application/x-httpd-php .php 
  LoadModule php5_module &quot;c:/php/sapi/php5apache2_2.dll&quot;</pre>
  </li>
  <li>Se as linhas estiverem ausentes, adicione-as, salve o <tt>httpd.conf</tt> e reinicie o Apache.</li>
  <li>Atualize a página http://localhost:&lt;port>/test.php.   </li>
</ol>
<h3><a name="installMySQL"></a>Servidor de Banco de Dados MySQL</h3>
<p>Encontre informações detalhadas em <a href="../ide/install-and-configure-mysql-server.html">instalando e configurando o servidor de banco de dados MySQL</a>. </p>
<h3><a name="installXDebug"></a>XDebug  </h3>
<ol>
<li>Faça download do <a href="http://www.xdebug.org" target="_blank">XDebug</a>.</li>
<li>Instale o XDebug na pasta <tt>php/</tt>. Você precisará do caminho para a pasta para <a href="#settingUpEnvironment">configurar o ambiente</a>.</li>
</ol>

<h3><a name="settingUpEnvironment"></a>Configurando o Ambiente  </h3>
<ol>
  <li>Se a sua instalação seguir as definições default, o processamento do PHP será ativado automaticamente. </li>
  <li>Para anexar o <a id="attachXDebug" name="attachXDebug"></a> XDebug ao mecanismo PHP, localize o arquivo <tt>php.ini</tt> e adicione as seguintes linhas a ele:
  <p>Para um mecanismo PHP 5.2 <strong>seguro para thread</strong>:  
  <pre class="examplecode">zend_extension_ts=&quot;&lt;path to the php folder&gt;/php_xdebug-&lt;version-number&gt;.dll&quot;
xdebug.remote_enable=1</pre>
<p>Para um mecanismo PHP 5.2 <strong>não seguro para thread</strong>: </p>
<pre class="examplecode">zend_extension_nts="&lt;path to the php folder&gt;/php_xdebug-&lt;version-number&gt;.dll"
xdebug.remote_enable=1</pre>
<p>Para <b>qualquer</b> mecanismo PHP 5.3:</p>
<pre class="examplecode">zend_extension="&lt;path to the php folder&gt;/php_xdebug-&lt;version-number&gt;.dll"
xdebug.remote_enable=1</pre>

  <p>Alguns usuários observam também que podem precisar incluir as seguintes linhas, embora outros usuários não precisem:</p>
<pre>xdebug.remote_host=127.0.0.1<br>xdebug.remote_port=9000
; Port number must match debugger port number in NetBeans IDE Tools &gt; Options &gt; PHP<br>xdebug.remote_handler=dbgp<br></pre>
  <p>Clique <a href="http://www.xdebug.org/docs/install" target="_blank">aqui</a> para obter mais informações sobre como configurar o XDebug.</p>
  <p class="notes"><strong>Observação:</strong> certifique-se de que os caminhos especificados coincidam com os nomes e os locais dos arquivos correspondentes, conforme determinado durante a instalação.</p></li>
  <li>Para ter certeza de que o mecanismo PHP instalado anteriormente suporte a utilização do servidor de banco de dados MySQL:
    <ol type="a">
      <li type="a">Clique em Iniciar > Painel de Controle.</li>
      <li type="a">No Painel de Controle, selecione Adicionar ou Remover Programas. </li>
      <li type="a">No painel Adicionar ou Remover Programas, selecione a área PHP &lt;número de versão> área e clique em Alterar. O Assistente Configuração do PHP será Iniciado. Clique em Próximo.</li>
      <li type="a">No painel Alterar, reparar ou remover instalação, selecione Alterar e clique em Próximo. </li>
      <li>No painel Configuração do Servidor Web, selecione a versão do servidor Apache: no nosso exemplo é o Módulo Apache 2.2.x. Clique em Próximo.</li>
      <li>No painel Diretório de Configuração do Apache, especifique o diretório onde o arquivo de configuração do Apache <tt>httpd.conf</tt> está localizado. Clique em Próximo.</li>
      <li>No painel Escolher Itens para Instalar, expanda o nó Extensões e selecione os itens MySQL e MySQLi. Clique em Próximo.</li>
      <li>No painel Pronto para alterar PHP &lt;número de versão>, clique em Alterar.</li>
      <li>No painel Assistente de Configuração do PHP &lt;número de versão> Concluído, clique em Finalizar.</li>
    </ol>
    <br></li>
  </ol>
  </div>
  <div class="feedback-box" ><a href="/about/contact_form.html?to=3&amp;subject=Feedback:%20Configuring%20PHP%20on%20Windows">Enviar Feedback neste Tutorial</a></div>
<br style="clear:both;" />

<p>Para enviar comentários e sugestões, obter suporte e manter-se informado sobre os desenvolvimentos mais recentes das funcionalidades de desenvolvimento PHP do NetBeans IDE, <a href="../../../community/lists/top.html">junte-se à lista de correspondência users@php.netbeans.org</a>.</p>
<a href="../../trails/php.html">Voltar à Trilha do Aprendizado PHP</a>
</body>
</html>
