// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Protegendo uma aplicação Web no NetBeans IDE
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Protegendo uma aplicação Web no NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Protegendo uma aplicação Web no NetBeans IDE

Contribuição de Dan Kolar, Manutenção de James Branam e Jeff Rubinoff

Este documento lhe orienta a respeito dos conceitos básicos da adição de segurança a uma aplicação Web implantada em um servidor Oracle GlassFish Open Source Edition, Oracle WebLogic ou Apache Tomcat.

Este documento mostra como configurar a autenticação de segurança usando uma janela de log-in básico e usando também um form de log-in em uma página Web. Este documento guia você pelas etapas de criação de usuários no servidor Tomcat e no GlassFish Server. Depois de criar os usuários, você cria as atribuições de segurança, definindo as propriedades de segurança no descritor de implantação. Este documento também mostra como usar a autenticação JDBC para proteger sua aplicação durante a implantação do GlassFish Server.

*Duração esperada: _40 _minutos*


image::images/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"]


*Para seguir este tutorial, são necessários os recursos e o software a seguir.*

|===
|Software ou Recurso |Versão Necessária 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |Versão Java EE 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Developer Kit)+] |Versão 7 ou 8 

|Plataforma Java EE |Java EE 6 ou 7 

|Travel Database |Não é Obrigatório 

|Servidor de aplicações ou Web compatível com Java EE |Servidor Web Tomcat 7.x ou 8.x, Oracle WebLogic 11g ou
GlassFish Server Open Source Edition 4.x 
|===


== Instalando e Configurando o Ambiente de Trabalho

Instale e inicie o NetBeans IDE. Você pode seguir este tutorial usando o servidor Tomcat fornecido ou o GlassFish Server.

Verifique se o servidor está instalado e se há uma instância do servidor registrada no IDE. Você pode usar o Gerenciador de Servidores para registrar uma instância do servidor instalado. (Selecione Ferramentas > Servidores > Adicionar Servidor. Selecione “GlassFish Server <número da versão>” ou “Tomcat <número da versão>” e clique em Próximo. Clique em Procurar e localize o diretório de instalação do servidor de aplicações. Clique em Finalizar.)


==  Criando a Aplicação Web

Neste exercício, você primeiro cria o projeto de aplicação Web e a estrutura do diretório. Em seguida, você cria alguns arquivos  ``html``  simples em cada um dos diretórios seguros. A aplicação Web utiliza uma autenticação de log-in básico para acessar os diretórios seguros. Se quiser usar um form de log-in para autenticação, você pode adicionar uma página  ``jsp``  com o form.


=== Criando os Diretórios Seguros

1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N), selecione Aplicação Web na categoria Java Web e clique em Próximo.
2. Chame o projeto de  ``WebApplicationSecurity`` . Aceite as definições default.
3. (Opcional) Marque a caixa de seleção Utilizar Pasta Dedicada para Armazenamento de Bibliotecas e especifique o local da pasta de bibliotecas. Consulte link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG455[+Compartilhando uma Biblioteca com Outros Usuários+] em _Desenvolvendo Aplicações com o NetBeans IDE_ para obter mais informações sobre essa opção.
4. Clique em Próximo.
5. Selecione o servidor no qual deseja implantar a aplicação. Somente os servidores registrados com o IDE serão listados. Clique em Próximo.
6. Não é necessário adicionar um framework; portanto, clique em Finalizar.
7. Se você criou uma aplicação EE 6, vá à janela Projetos do IDE, clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro > Web > Descritor de Implantação Padrão (web.xml). Aceite todos os defaults e percorra o assistente.

*Observação:* este tutorial mostra como configurar a segurança no descritor de implantação, mas as aplicações EE 6 e EE 7 usam anotações em vez de um descritor de implantação, por padrão.

8. Se estiver usando um GlassFish ou WebLogic Server e o NetBeans IDE 7.0.1 ou posterior, você precisará gerar um descritor específico para o servidor. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro > GlassFish > Descritor do GlassFish ou Novo > Outro > WebLogic > Descritor do WebLogic. A caixa de diálogo Criar Descritor Específico do Servidor será aberta. Aceite todos os defaults e clique em Finalizar. O descritor específico do servidor, chamado  ``glassfish-web.xml``  ou  ``weblogic.xml`` , aparecerá no projeto na pasta Arquivos de Configuração.
9. Na janela Projetos do IDE, clique com o botão direito do mouse em Páginas Web e selecione Novo > Outro.
10. No assistente de Novo Arquivo, selecione Outro como Categoria e Pasta como o Tipo de Arquivo. Clique em Próximo.
11. 
No assistente de Nova Pasta, chame a pasta de secureAdmin e clique em Finalizar.

A pasta secureAdmin será exibida na janela Projetos da pasta Páginas Web.
12. Repita as três últimas etapas para criar outra pasta chamada secureUser.
13. Crie um novo arquivo  ``html``  na pasta secureUser, clicando com o botão direito do mouse na janela Projetos e selecionando Novo > Outros.
14. Selecione o tipo de arquivo HTML na categoria Outro. Clique em Próximo.
15. Chame o novo arquivo de pageU e clique em Finalizar.

Quando você clica em Finalizar, o arquivo  ``pageU.html``  é aberto no Editor de Código-Fonte.

16. No Editor de Código-Fonte, substitua o código existente em  ``pageU.html``  pelo código a seguir:[html-tag]#<html>
   <head>
      <title>#

[source,xml]
----

User secure area[html-tag]#</title>
   </head>
   <body>
      <h1>#User Secure Area[html-tag]#</h1>
   </body>
</html>#
----
17. Clique com o botão direito do mouse na pasta secureAdmin e crie um novo arquivo  ``html``  chamado pageA.
18. No Editor de Código-Fonte, substitua o código existente em  ``pageA.html``  pelo código a seguir:[html-tag]#<html>
   <head>
      <title>#

[source,xml]
----

Admin secure area[html-tag]#</title>
   </head>
   <body>
      <h1>#Admin secure area[html-tag]#</h1>
   </body>
</html>#
----


=== Criando a Página de Índice JSP

Agora você criará a página de índice JSP contendo links para as áreas seguras. Quando o usuário clicar no link, será solicitado que ele forneça o nome de usuário e a senha. Se você estiver utilizando um log-in básico, esses dados serão solicitados na janela de log-in do browser default. Se você estiver utilizando uma página de form de log-in, o usuário informará o nome de usuário e a senha em um form.

1. Abra  ``index.jsp``  no Editor de Código-Fonte e adicione os seguintes links a  ``pageA.html``  e  ``pageU.html`` :[jsp-html-tag]#<p>#

[source,html]
----

Request a secure Admin page [jsp-html-tag]#<a# [jsp-html-argument]#href=#[jsp-xml-value]#"secureAdmin/pageA.html"#[jsp-html-tag]#>#here![jsp-html-tag]#</a></p>
<p>#Request a secure User page [jsp-html-tag]#<a# [jsp-html-argument]#href=#[jsp-xml-value]#"secureUser/pageU.html"# [jsp-html-tag]#>#here![jsp-html-tag]#</a></p>#
----
2. Salve as alterações.


=== Criando um Form de Log-in (obrigatório para Tomcat e opcional para GlassFish ou WebLogic Server)

Se você quiser usar um form de log-in em vez do log-in básico, crie uma página  ``jsp``  contendo o form. Em seguida, especifique o log-in e as páginas de erro ao <<Basic_login_config,configurar o método de log-in>>.

*Importante:* Os usuários do Tomcat devem criar um form de log-in.

1. Na janela Projetos, clique com o botão direito do mouse na pasta Páginas Web e selecione Novo > JSP.
2. Defina o nome do arquivo como  ``login`` , deixe os outros campos com seu valor default e clique em Finalizar.
3. No Editor de Código-Fonte, insira o código a seguir entre as tags  ``<body>``  de  ``login.jsp`` .

[source,xml]
----

<[jsp-html-tag]#form# [jsp-html-argument]#action=#[jsp-xml-value]#"j_security_check"# [jsp-html-argument]#method=#[jsp-xml-value]#"POST"#[jsp-html-tag]#>#
   Username:[jsp-html-tag]#<input# [jsp-html-argument]#type=#[jsp-xml-value]#"text"# [jsp-html-argument]#name=#[jsp-xml-value]#"j_username"#[jsp-html-tag]#><br>#
   Password:[jsp-html-tag]#<input# [jsp-html-argument]#type=#[jsp-xml-value]#"password"# [jsp-html-argument]#name=#[jsp-xml-value]#"j_password"#[jsp-html-tag]#>
   <input# [jsp-html-argument]#type=#[jsp-xml-value]#"submit"# [jsp-html-argument]#value=#[jsp-xml-value]#"Login"#[jsp-html-tag]#>
</form>#
----
4. Crie um novo arquivo  ``html``  chamado  ``loginError.html``  na pasta Páginas Web. Trata-se de uma página de erro simples.
5. No Editor de Código-Fonte, substitua o código existente em  ``loginError.html``  pelo código a seguir:[html-tag]#<html>
    <head>
        <title>#

[source,xml]
----

Login Test: Error logging in[html-tag]#</title>
    </head>
    <body>
        <h1>#Error Logging In[html-tag]#</h1>
        <br/>
    </body>
</html>#
----


== Criando Usuários no Servidor de Destino

Para poder usar a segurança da autenticação de usuário/senha (log-in básico ou log-in com base em form) em aplicações Web, os usuários e suas atribuições apropriadas devem ser definidos no servidor de destino. Para fazer log-in em um servidor, a conta do usuário precisa existir nesse servidor.

A forma como você define os usuários e as atribuições varia de acordo com o servidor de destino especificado. Neste tutorial, os usuários  ``admin``  e  ``user``  são usados para testar a configuração da segurança. Você precisa confirmar que esses usuários existem nos respectivos servidores, e que as atribuições apropriadas estejam designadas aos usuários.


=== Definindo Usuários no GlassFish Server

Para este cenário, você precisará usar a Console de Administração do GlassFish Server para criar dois novos usuários chamados  ``user``  e  ``admin`` . O usuário chamado  ``user``  terá acesso limitado à aplicação, enquanto que o  ``admin``  terá privilégios de administração.

1. Abra a Console de Administração na janela Serviços do IDE e clique com o botão da direita do mouse em Servidores > GlassFish Server > Exibir Console de Administração do Domínio. A página de log-in do GlassFish Server será aberta na janela do browser. Você deverá fazer log-in usando o nome de usuário e a senha de administrador para acessar a Console de Administração.

*Observação: *O Servidor de Aplicações deve estar em execução antes de você acessar a Console de Administração. Para iniciar o servidor, clique com o botão direito do mouse no nó do GlassFish Server e selecione Iniciar.

2. Na Console de Administração, vá até Configurações > server-config > Segurança > Realms > Arquivo. O painel Editar Realm será aberto.
image::images/edit-realm.png[]
3. Clique no botão Gerenciar Usuários na parte superior do painel Editar Realm. O painel Usuários do Arquivo será aberto.
image::images/file-users.png[]
4. Clique em Novo. O painel Novo Usuário do Realm do Arquivo será aberto. Digite  ``user``  como o ID de usuário e  ``userpw01``  como a senha. Clique em OK.
5. Siga as etapas anteriores para criar um usuário chamado  ``admin``  com a senha  ``adminpw1``  no realm  ``file`` .


=== Definindo Atribuições e Usuários no Servidor Web Tomcat

Para Tomcat 7, crie um usuário com a atribuição de script de gerência e uma senha para esse usuário ao registrar o servidor no NetBeans IDE.

Os usuários e as atribuições básicas para o servidor Tomcat estão em  ``tomcat-users.xml`` . Você encontra  ``tomcat-users.xml``  no diretório  ``_<CATALINA_BASE>_\conf`` .

*Observação:* Você encontra a localização CATALINA_BASE clicando com o botão direito do mouse no nó do servidor Tomcat na janela Serviços e selecionando Propriedades. As Propriedades do Servidor serão abertas. A localização de CATALINA_BASE encontra-se na guia Conexão.

image::images/tomcat-properties.png[] image::images/catalina-base.png[]

*Observação:* Se você usar o Tomcat 6 fornecido com versões mais antigas do IDE, este servidor terá o usuário  ``ide``  definido com uma senha e as atribuições de administrador e gerenciador. A senha do usuário  ``ide``  é gerada quando o Tomcat 6 é instalado. Você pode alterar a senha do usuário  ``ide``  ou copiar a senha em  ``tomcat-users.xml`` .

*Para adicionar usuários ao Tomcat:*

1. Abra  ``_<CATALINA_BASE>_/conf/tomcat-users.xml``  em um editor.
2. Adicione uma atribuição chamada  ``AdminRole`` .

[source,java]
----

<role rolename="AdminRole"/>
----
3. Adicione uma atribuição chamada  ``UserRole`` .

[source,java]
----

<role rolename="UserRole"/>
----
4. Adicione um usuário chamado  ``admin``  com a senha  ``adminpw1``  e a atribuição  ``AdminRole`` .

[source,java]
----

<user username="admin" password="adminpw1" roles="AdminRole"/>
----
5. Adicione um usuário chamado  ``user``  com a senha  ``userpw01``  e a atribuição  ``UserRole`` .

[source,java]
----

<user username="user" password="userpw01" roles="UserRole"/>
----

O arquivo  ``tomcat-users.xml``  terá a seguinte aparência:


[source,xml]
----

<tomcat-users>
<!--
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="both" password="tomcat" roles="tomcat,role1"/>
  <user username="role1" password="tomcat" roles="role1"/>
-->
...
<role rolename="AdminRole"/>
<role rolename="UserRole"/>
<user username="user" password="userpw01" roles="UserRole"/>
<user username="admin" password="adminpw1" roles="AdminRole"/>
[User with manager-script role, defined when Tomcat 7 was registered with the IDE]
...
</tomcat-users>
----


=== Definindo Usuários e Grupos no WebLogic Server

Para este cenário, é necessário primeiro usar a Console de Administração do WebLogic Server para criar dois novos usuários chamados  ``user``  e  ``admin`` . Adicione esses usuários aos grupos  ``userGroup``  e  ``adminGroup`` , respectivamente. Posteriormente, você designará atribuições de segurança a esses grupos. O  ``userGroup``  terá acesso limitado à aplicação, enquanto que o  ``adminGroup``  terá privilégios de administração.

As instruções gerais sobre como adicionar usuários e grupos ao servidor WebLogic se encontram na link:http://download.oracle.com/docs/cd/E21764_01/apirefs.1111/e13952/taskhelp/security/ManageUsersAndGroups.html[+Ajuda On-Line da Console de Administração+] do WebLogic.

*Para adicionar os usuários “user” e “admin” e os grupos ao WebLogic:*

1. Abra a Console de Administração na janela Serviços do IDE e clique com o botão direito do mouse em Servidores > WebLogic Server > Exibir Console de Administração. A página de log-in do GlassFish Server será aberta na janela do browser. Você deverá fazer log-in usando o nome de usuário e a senha de administrador para acessar a Console de Administração.

*Observação: *O Servidor de Aplicações deve estar em execução antes de você acessar a Console de Administração. Para iniciar o servidor, clique com o botão direito do mouse no nó do WebLogic Server e selecione Iniciar.

2. No painel esquerdo, selecione Realms de Segurança. A página Resumo de Realms de Segurança será aberta.
3. Na página Resumo de Realms de Segurança, selecione o nome do realm (o realm default é “myrealm”). A página Definições de Nome do Realm será aberta.
4. Na página Definições de Nome do Realm, selecione Usuários e Grupos > Usuários. A tabela Usuários será exibida.
5. Na tabela Usuários, clique em Novo. A página Criar Novo Usuário será aberta.
6. Digite no nome “user” e na senha “userpw01”. Opcionalmente, digite uma descrição. Aceite o Provedor de Autenticação default. 
image::images/wl-admin-newuser.png[]
7. Clique em OK. Retorne para a tabela Usuários.
8. Clique em Novo e adicione um usuário chamado “admin” e a senha “admin1”.
9. Abra a guia Grupos. A tabela Grupos será exibida.
10. Clique em Novo. A janela Criar um Novo Grupo será aberta.
11. Defina o nome do grupo como userGroup. Aceite o provedor default e clique em OK. Você retornará para a tabela Grupos.
12. Clique em Novo e crie o grupo adminGroup.
13. Abra a guia Usuários para o próximo procedimento.

Agora, adicione o usuário  ``admin``  ao  ``adminGroup``  e o usuário  ``user``  ao  ``userGroup`` .

*Para adicionar usuários a grupos:*

1. Na guia Usuários, clique no usuário  ``admin`` . A página Definições do usuário será aberta.
2. Na página Definições, abra a guia Grupos.
3. Nos Grupos Pai: Disponível: tabela, selecione  ``adminGroup`` .
4. Clique na seta para a direita, >. O  ``adminGroup``  será exibido nos Grupos Pais: Selecionado: tabela.
image::images/wl-admin-usersettings.png[]
5. Clique em Salvar.
6. Retorne à guia Usuários.
7. Clique no usuário  ``user``  e adicione-o ao  ``userGroup`` .


== Configurando o Método de Log-in

Ao configurar o método de log-in da aplicação, você pode usar a janela de log-in fornecida pelo browser para autenticação de log-in básico. Como alternativa, você pode criar uma página Web com um form de log-in. Ambos os tipos de configuração de log-in são baseadas na autenticação de usuário/senha.

Para configurar o log-in, crie _restrições de segurança_ e designe atribuições a elas. As restrições de segurança definem um conjunto de arquivos. Quando você designa uma atribuição a uma restrição, os usuários com essa atribuição passam a ter acesso aos conjuntos de arquivos definidos pela restrição. Por exemplo, neste tutorial você designa a atribuição AdminRole à restrição AdminConstraint e as atribuições UserRole e AdminRole à restrição UserConstraint. Isso significa que os usuários com a AdminRole têm acesso aos arquivos de Administrador e arquivos de Usuário, mas os usuários com a UserRole têm acesso somente ao arquivos de Usuário.

*Observação:* Não é um caso comum conceder o acesso separado da atribuição de administrador para arquivos de usuário. Uma alternativa é designar somente a UserRole à UserConstraint e, no lado do servidor, conceder a AdminRole a *usuários* específicos que também são administradores. Você deve decidir como o acesso será concedido caso a caso.

Configure o método de log-in para a aplicação, configurando  ``web.xml`` . O arquivo  ``web.xml``  pode ser encontrado no diretório Arquivos de Configuração da janela Projetos.


=== Log-in Básico

Quando você utiliza a configuração de log-in básico, a janela de log-in é fornecida pelo browser. É necessário ter um nome de usuário e uma senha válidos para acessar o conteúdo seguro.

As seguintes etapas mostram como configurar um log-in básico para GlassFish Servers e WebLogic Servers. Usuários Tomcat precisam usar o <<form-login,log-in com form>>.

*Para configurar o log-in básico:*

1. Na janela Projetos, expanda o nó Arquivos de Configuração do projeto e clique duas vezes em  ``web.xml`` . O arquivo  ``web.xml``  será aberto no Editor Visual.
2. Clique em Segurança na barra de ferramentas para abrir o arquivo na view Segurança.
3. Expanda o nó Configuração de Log-in e defina a Configuração de Log-in como Básico.

*Observação: *Se você quiser usar um form, selecione Form em vez de Básico e especifique o log-in e as páginas de erro de log-in.

4. Insira um nome de realm, dependendo do seu servidor.
* *GlassFish:* Especifique  ``file``  como o Nome do Realm. Este é o nome default do realm onde você criou os usuários no GlassFish Server.
* *Tomcat:* Não especifique um nome de realm.
* *WebLogic:* Especifique o nome do realm. O realm default é  ``myrealm`` .
image::images/security-roles.png[]
5. Expanda o nó Atribuições de Segurança e clique em Adicionar para adicionar um nome de atribuição.
6. Adicione as Seguintes Atribuições de Segurança:
*  ``AdminRole`` . Os usuários adicionados a esta atribuição terão acesso ao diretório  ``secureAdmin``  do servidor.
*  ``UserRole`` . Os usuários adicionados a esta atribuição terão acesso ao diretório  ``secureUser``  do servidor.

*Cuidado:* os nomes de atribuição no GlassFish devem começar com letra maiúscula.

7. Crie e configure um restrição de segurança chamada  ``AdminConstraint`` , fazendo o seguinte:
1. Clique em Adicionar Restrição de Segurança. Será exibida uma seção para a nova restrição de segurança.
2. Indique  ``AdminConstraint``  para o Nome de View da nova restrição de segurança.
image::images/admin-constraint.png[]
3. Clique em Add. A caixa de diálogo Adicionar Recurso da Web é aberta.
4. 
Na caixa de diálogo Adicionar Recurso da Web, defina o Nome do Recurso como  ``Admin``  e o Padrão de URL como  ``/secureAdmin/*``  e clique em OK. A caixa de diálogo é fechada.

*Observação: * Ao utilizar um asterisco (*), você permite que o usuário tenha acesso a todos os arquivos dessa pasta.

image::images/addwebresource.png[]
5. Selecione Ativar Restrição de Autenticação e clique em Editar. A caixa de diálogo Editar Nomes de Atribuições será aberta.
6. Na caixa de diálogo Editar Nomes de Atribuições, selecione AdminRole no painel esquerdo, clique em Adicionar e em OK.

Depois de concluídas as etapas acima, o resultado deverá ser semelhante à figura a seguir:

image::images/constraints.png[]
8. Crie e configure uma restrição de segurança chamada  ``UserConstraint`` , fazendo o seguinte:
1. Clique em Adicionar restrição de segurança para criar uma nova restrição de segurança.
2. Indique  ``UserConstraint``  para o Nome de View da nova restrição de segurança.
3. Clique em Adicionar para adicionar uma Coleção de Recursos da Web.
4. Na caixa de diálogo Adicionar Recurso da Web, defina o Nome do Recurso como  ``User``  e o Padrão de URL como  ``/secureUser/*``  e clique em OK.
5. Selecione Ativar Restrição de Autenticação e clique em Editar para editar o campo Nome da Atribuição.
6. Na caixa de diálogo Editar Nomes de Atribuições, selecione AdminRole e UserRole no painel esquerdo, clique em Adicionar e em OK.
Observação: Você também pode definir o time-out da sessão em web.xml. Para definir o time-out, clique na guia Geral do Editor Visual e especifique quanto tempo você deseja que a sessão dure. O default é 30 minutos. 
 

=== Log-in com Form

A utilização de um form para log-in permite que você personalize o conteúdo das páginas de log-in e de erro. As etapas para configurar a autenticação usando um form são as mesmas para a configuração do log-in básico, com a diferença que você especifica as <<loginform,páginas de log-in e de erro>> criadas.

As seguintes etapas mostram como configurar um form para log-in

1. Na janela Projetos, clique duas vezes em  ``web.xml``  localizado no diretório  ``Web Pages/WEB-INF``  para abrir o arquivo no Editor Visual.
2. Clique em Segurança na barra de ferramentas para abrir o arquivo na view Segurança e expanda o nó Configuração de Log-in.
3. Defina a Configuração de Log-in como Form.
4. Defina a Página de Log-in com Form, clicando em Procurar e localizando  ``login.jsp`` .
5. 
Defina a Página de Erro de Form, clicando em Procurar e localizando  ``loginError.html`` .

image::images/login-forms.png[]
6. Insira um nome de realm, dependendo do seu servidor.
* *GlassFish:* Especifique  ``file``  como o Nome do Realm. Este é o nome default do realm onde você criou os usuários no GlassFish Server.
* *Tomcat:* Não especifique um nome de realm.
* *WebLogic:* Especifique o nome do realm. O realm default é  ``myrealm`` .
7. Expanda o nó Atribuições de Segurança e clique em Adicionar para adicionar um nome de atribuição.
8. Adicione as Seguintes Atribuições de Segurança:
|===

|Atribuição Servidor |Descrição 

|AdminRole |Os usuários adicionados a esta atribuição terão acesso ao diretório  ``secureAdmin``  do servidor. 

|UserRole |Os usuários adicionados a esta atribuição terão acesso ao diretório  ``secureUser``  do servidor. 
|===
9. Crie e configure um restrição de segurança chamada  ``AdminConstraint`` , fazendo o seguinte:
1. Clique em Adicionar restrição de segurança para criar uma nova restrição de segurança.
2. Especifique  ``AdminConstraint``  para o Nome de View da nova restrição de segurança.
3. Clique em Adicionar para adicionar uma Coleção de Recursos da Web.
4. 
Na caixa de diálogo Adicionar Recurso da Web, defina o Nome do Recurso como  ``Admin``  e o Padrão de URL como  ``/secureAdmin/*``  e clique em OK.

*Observação: * Ao utilizar um asterisco (*), você permite que o usuário tenha acesso a todos os arquivos dessa pasta.

image::images/addwebresource.png[]
5. Selecione Ativar Restrição de Autenticação e clique em Editar. A caixa de diálogo Editar Nomes de Atribuições será aberta.
6. Na caixa de diálogo Editar Nomes de Atribuições, selecione AdminRole no painel esquerdo, clique em Adicionar e em OK.

Depois de concluídas as etapas acima, o resultado deverá ser semelhante à figura a seguir:

image::images/constraints.png[]
10. Crie e configure uma restrição de segurança chamada  ``UserConstraint`` , fazendo o seguinte:
1. Clique em Adicionar restrição de segurança para criar uma nova restrição de segurança.
2. Indique  ``UserConstraint``  para o Nome de View da nova restrição de segurança.
3. Clique em Adicionar para adicionar uma Coleção de Recursos da Web.
4. Na caixa de diálogo Adicionar Recurso da Web, defina o Nome do Recurso como  ``User``  e o Padrão de URL como  ``/secureUser/*``  e clique em OK.
5. Selecione Ativar Restrição de Autenticação e clique em Editar para editar o campo Nome da Atribuição.
6. Na caixa de diálogo Editar Nomes de Atribuições, selecione AdminRole e UserRole no painel esquerdo, clique em Adicionar e em OK.
Observação: Você também pode definir o time-out da sessão em web.xml. Para definir o time-out, clique na guia Geral do Editor Visual e especifique quanto tempo você deseja que a sessão dure. O default é 30 minutos.


== Configurando os Descritores de Implantação de Servidor

Se você estiver implantando sua aplicação em um GlassFish Server ou WebLogic Server, será necessário configurar o descritor de implantação de servidor para mapear as atribuições de segurança definidas em  ``web.xml`` . O descritor de implantação de servidor está listado no nó Arquivos de Configuração do seu projeto na janela Projetos.


=== Configurando o Descritor de Implantação do GlassFish Server

O descritor de implantação do GlassFish Server é chamado de  ``glassfish-web.xml`` . O descritor de implantação de servidor se encontra na pasta Arquivos de Configuração. Se não for esse o caso, crie o descritor clicando com o botão direito do mouse no nó do projeto e selecionando Novo > Outro > GlassFish > Descritor de Implantação do GlassFish. Aceite todos os defaults.

Observe que os valores inseridos em  ``web.xml``  serão exibidos em  ``glassfish-web.xml`` . O IDE pega esses valores do  ``web.xml``  para você.

*Para configurar o descritor de implantação do GlassFish:*

1. Na janela Projetos, expanda o nó Arquivos de Configuração do projeto e clique duas vezes em  ``glassfish-web.xml`` . O descritor de implantação do  ``glassfish-web.xml``  será aberto em um editor especial tabulado para descritores de implantação do GlassFish.

*Observação:* Em versões do GlassFish Server anteriores à 3.1, esse arquivo é chamado  ``sun-web.xml`` .

2. Selecione a guia Segurança para revelar as atribuições de segurança.
3. Selecione o nó da atribuição de segurança AdminRole para abrir o painel Mapeamento de Atribuição de Segurança.
4. 
Clique em Adicionar principal e especifique  ``admin``  como o nome principal. Clique em OK.

image::images/add-principal.png[]
5. Selecione o nó da atribuição de segurança UserRole para abrir o painel Mapeamento de Atribuição de Segurança.
6. Clique em Adicionar Principal e especifique  ``user``  como o nome principal. Clique em OK
7. Salve as alterações em  ``glassfish-web.xml`` .

Também é possível exibir e editar o  ``glassfish-web.xml``  no editor de XML clicando na guia XML. Se você abrir o  ``glassfish-web.xml``  no editor XML, você verá que o  ``glassfish-web.xml``  possui as seguintes informações de mapeamento de atribuição de segurança:

[xml-tag]#<security-role-mapping>
    <role-name>#

[source,xml]
----

AdminRole[xml-tag]#</role-name>
    <principal-name>#admin[xml-tag]#</principal-name>
</security-role-mapping>
<security-role-mapping>
    <role-name>#UserRole[xml-tag]#</role-name>
    <principal-name>#user[xml-tag]#</principal-name>
</security-role-mapping>#
----


=== Configurando o Descritor de Implantação do WebLogic Server

O descritor de implantação do WebLogic é chamado de  ``weblogic.xml`` . Atualmente, o <<gf-dd,suporte para descritores de implantação do GlassFish>> do IDE não se estende aos descritores de implantação do WebLogic. Portanto, você precisa fazer todas as alterações no  ``weblogic.xml``  manualmente.

O descritor de implantação do WebLogic Server se encontra na pasta Arquivos de Configuração. Se não for esse o caso, crie o descritor clicando com o botão direito do mouse no nó do projeto e selecionando Novo > Outro > WebLogic > Descritor de Implantação do WebLogic. Aceite todos os defaults.

*Observação:* Para obter mais informações sobre a segurança de aplicações Web no WebLogic, incluindo segurança declarativa e programática, consulte link:http://download.oracle.com/docs/cd/E21764_01/web.1111/e13711/thin_client.htm[+Oracle Fusion Middleware Programming Security for Oracle WebLogic Server.+].

*Para configurar o descritor de implantação do WebLogic:*

1. Na janela Projetos, expanda o nó Arquivos de Configuração do projeto e clique duas vezes em  ``weblogic.xml`` . O descritor de implantação do  ``weblogic.xml``  será aberto no Editor.
2. Dentro do elemento  ``<weblogic-web-app>`` , digite ou cole os seguintes elementos de designação de atribuição de segurança:[xml-tag]#<security-role-assignment>
    <role-name>#

[source,xml]
----

AdminRole[xml-tag]#</role-name>
    <principal-name>#adminGroup[xml-tag]#</principal-name>
</security-role-assignment>
<security-role-assignment>
    <role-name>#UserRole[xml-tag]#</role-name>
    <principal-name>#userGroup[xml-tag]#</principal-name>
</security-role-assignment>#
----
3. Salve as alterações em  ``weblogic.xml`` .


== Implantando e Executando a Aplicação

Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Executar.

*Observação:* Por default, o projeto foi criado com a funcionalidade Compilar ao Salvar ativado, então, não é necessário compilar o código primeiro para executar a aplicação no IDE. Para obter mais informações sobre a funcionalidade Compile on Save, consulte link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG510[+Building Java Projects+] no _Developing Applications with NetBeans IDE User's Guide_.

Após a construção e a implantação da aplicação no servidor, a página inicial será aberta no seu Web browser. Selecione a área segura que deseja acessar, clicando em *admin* ou *user*.

image::images/deploy1.png[]

Após o fornecimento de usuário e senha, existem três resultados possíveis:

* A senha deste usuário está correta e o usuário tem privilégios para o conteúdo protegido -> a página de conteúdo protegido será exibida

image::images/deploy2.png[]
* 
A senha deste usuário está incorreta -> A página de erro será exibida

image::images/deploy3.png[]
* 
A senha deste usuário está correta, mas o usuário não tem direito a acessar o conteúdo protegido -> o browser exibe Erro 403 O acesso ao recurso solicitado foi negado

image::images/deploy4.png[]


== Resumo

Neste tutorial, você criou uma aplicação Web protegida. Você editou as definições de segurança usando os editores de Descritor web.xml e glassfish-web.xml, criando páginas Web com log-ins seguros e diversas identidades.


== Consulte Também

* link:quickstart-webapps.html[+Introdução ao Desenvolvimento de Aplicações Web+]
* link:../../trails/java-ee.html[+Trilha de Aprendizado do Java EE e Java Web+]


|===
|
link:/about/contact_form.html?to=3&subject=Feedback: Securing a Web Application[+Enviar Feedback neste Tutorial+]

 
|===