Computacao em nuvens com Google App Engine e Java

UNIVERSIDADE ESTADUAL DE MARINGÁ – UEM
ESPECIALIZAÇÃO EM DESENVOLVIMENTO DE SISTEMAS PARA WEB – ESPWEB
BRUNO THEODORO DE AQUINO
ORIENTADOR: MESTRE MUNIF GEBARA JÚNIOR
COMPUTAÇÃO EM NUVENS COM GOOGLE APP ENGINE E JAVA
MARINGÁ
2013
BRUNO THEODORO DE AQUINO
COMPUTAÇÃO EM NUVENS COM GOOGLE APP ENGINE
Trabalho submetido à Universidade Estadual
de Maringá como requisito para a obtenção de
título de Especialista em Desenvolvimento de
Software para Web.
Orientador: Prof. Mestre Munif Gebara Júnior
MARINGÁ
2013
RESUMO
With the popularization of the internet and its continuous improvement, cloud computing has
grown greatly in recent years. His model is service-oriented and can be divided into: software
as a service, platform as a service, infrastructure as a service and storage as a service. Several
companies have set up their development platforms in the clouds, as the case of Google and
Amazon, studied in this work. Also shown are the first steps of how to create an application
on the Google platform using the Eclipse IDE with the Plug-in SDK, the Java language. A
proposed example was created by Google and shown its development, that is persisted using
JDO.
Keywords: Cloud computing. Google App Engine. Amazon Web Services, AWS Elastic
Beanstalk.
ABSTRACT
With the popularization of the Internet and its constant improvements, cloud computing has
grown tremendously in recent years. His model is service-oriented and can be divided into:
software as a service, platform as a service, infrastructure as a service and storage as a service.
Several companies have set up their development platforms in the clouds, as the case of
Google and Amazon, studied in this work. Also shows the first steps in creating an application
in the Google platform using the Eclipse IDE, the plug-in SDK, the Java liguagem. It created
an example proposed by Google, and shown its development, that is persisted using JDO.
Key words: Cloud Computing. Google App Engine. Amazon Web Services, AWS Elastic
Beanstalk.
Sumário
1 Introdução................................................................................................................................8
1.1 Objetivo............................................................................................................................8
1.2 Justificativa.......................................................................................................................8
1.3 Motivação.........................................................................................................................8
1.4 Estrutura do Trabalho.......................................................................................................9
2 Fundamentação Teórica..........................................................................................................10
2.1 Computação em Nuvens.................................................................................................10
2.2 Características.................................................................................................................11
2.2.5 Customização..........................................................................................................12
2.3 Modelo de Serviço..........................................................................................................12
2.3.1 Infraestrutura como Serviço – IaaS........................................................................12
2.3.2 Plataforma como serviço – PaaS............................................................................13
2.3.3 Software como Serviço – SaaS...............................................................................13
2.3.4 Demais serviços......................................................................................................13
2.4 Modelo de Implantação..................................................................................................14
2.4.1 Privado....................................................................................................................14
2.4.2 Pública....................................................................................................................15
2.4.3 Comunidade............................................................................................................16
2.4.4 Hibrido....................................................................................................................16
2.5 Google App Engine........................................................................................................17
2.5.1 Funcionalidades do GAE........................................................................................18
2.6 Amazon Web Services (AWS)........................................................................................20
2.6.1 Funcionalidades do AWS Elastic Beanstalk...........................................................20
2.7 GAE x AWS...................................................................................................................22
2.7.1 Ambiente de Desenvolvimento...............................................................................22
2.7.2 Armazenamento......................................................................................................22
2.7.3 Definição de Preços e Limites................................................................................23
2.7.4 Plataforma Java.......................................................................................................23
3 Aplicação com Google App Engine.......................................................................................25
3.1 Preparando o Ambiente..................................................................................................25
3.1.1 Java Development Kit............................................................................................25
3.1.2 Plug-in do Google para IDE Eclipse......................................................................26
3.1.3 Testando a instalação..............................................................................................29
3.2 Criando o primeiro Projeto.............................................................................................29
3.2.1 Olá Mundo..............................................................................................................30
3.3 Mural de Mensagens......................................................................................................32
3.4 Persistência.....................................................................................................................32
3.4.1 DataNucleus Access Platform................................................................................32
3.4.2 Anotações JDO e POJOs........................................................................................33
3.4.3 Fábrica de Conexão e persistence.xml....................................................................34
3.4.4 Servlet.....................................................................................................................35
3.4.5 View (JSP)..............................................................................................................36
3.4.6 JDOSQL.................................................................................................................36
3.4.7 Como enviar o projeto com a IDE Eclipse.............................................................37
4 Conclusão...............................................................................................................................42
5 Referência bibliográfica.........................................................................................................44
Apêndices..................................................................................................................................45
Apêndice A – Classe BtajdoServlet......................................................................................46
Apêndice B – Mural.jsp........................................................................................................48
Apêndice C – Controle de Versão com Git..........................................................................50
Índice de figuras
Figura 1: Modelo de Serviço.....................................................................................................12
Figura 2: Modelo de Nuvem Privada........................................................................................15
Figura 3: Nuvem Pública..........................................................................................................16
Figura 4: Nuvem Comunitária..................................................................................................16
Figura 5: Nuvem Hibrida..........................................................................................................17
Figura 6: Ambiente de desenvolvimento Java..........................................................................18
Figura 7: Verificando instalação do Java..................................................................................26
Figura 8: Adicionando o link do Plug-in...................................................................................26
Figura 9: Adicionando nome e endereço do Download............................................................27
Figura 10: Escolhendo as ferramentas......................................................................................27
Figura 11: Detalhes dos recursos..............................................................................................28
Figura 12: Processo de instalação.............................................................................................28
Figura 13: Comando para Linux e MAC OS, [6].....................................................................29
Figura 14: Comando para Windows, [6]...................................................................................29
Figura 15: Estrutura do Projeto.................................................................................................30
Figura 16: Olá Mundo...............................................................................................................31
Figura 17: Execução do Olá Mundo.........................................................................................31
Figura 18: Configurações JDO.................................................................................................32
Figura 19: Classe com anotação JDO.......................................................................................33
Figura 20: Exemplo de fábrica de conexão...............................................................................34
Figura 21: persistence.xml........................................................................................................35
Figura 22: Servlet......................................................................................................................36
Figura 23: JSP...........................................................................................................................36
Figura 24: Exemplo de JDOSQL..............................................................................................37
Figura 25: Criando uma conta Google......................................................................................38
Figura 26: Criando o ID do Projeto..........................................................................................38
Figura 27: Formulário do ID.....................................................................................................39
Figura 28: Adicionando o ID no Projeto...................................................................................39
Figura 29: Enviando o projeto..................................................................................................40
Figura 30: Projeto mural de mensagens....................................................................................41
Figura 31...................................................................................................................................50
Figura 32: Fonte: Bitbucket. 2013............................................................................................51
Figura 33: Fonte: Bitbucket. 2013............................................................................................51
Figura 34: Fonte: Bitbucket. 2013............................................................................................52
Figura 35...................................................................................................................................53
Figura 36: Fonte: Bitbucket, 2013............................................................................................53
8
1 Introdução
Com o avanço cada vez mais rápido da internet, ter acesso às suas informações de qualquer
computador com acesso à rede, se tornou fundamental no mercado de hoje. A computação em
nuvens, vem trazendo esta possibilidade, onde empresas conseguem usar a infraestrutura de
terceiros, de qualquer dispositivo com acesso as nuvens.
1.1 Objetivo
O objetivo deste trabalho é apresenta o Google App Engine da Google, mostrando os passos
básicos para o desenvolvimento de uma aplicação simples em Java, utilizando a IDE de
desenvolvimento Eclipse. Além disso, será apresentado uma comparação com os recursos do AWS
Elastic Beanstalk, o serviço concorrente da Amazon.
1.2 Justificativa
Com o mercado cada vez mais competitivo, ter acesso a seus sistemas e informações de
qualquer lugar passou a ser fundamental. Com os serviços de computação em nuvens, empresas
terceirizam suas infraestruturas de servidores, e para acessar seus arquivos e aplicativos, basta ter
acesso as nuvens, ou seja, internet. Várias gigantes da internet, como a Google e Amazon,
começaram a disponibilizar sua infraestrutura de computação em nuvens, e são pioneiras no ramo.
Com está abordagem, diminuem os custos que as empresas teriam para bancar sua própria
infraestrutura de servidores, além de outros gastos como segurança, manutenção e atualização dos
equipamentos. A empresa teria recursos para focar em outros pontos estratégicos, justificando assim
este trabalho.
1.3 Motivação
Tanto para empresas como para usuários comuns, a computação em nuvens está cada dia mais
presente, pessoas ficam conectados a nuvem o tempo todo, seja por um computador pessoal ou
9
smartfones, é um mercado aquecido. Empresas estão migrando seus sistemas corporativos para
nuvens, e fornecendo seus serviços através dela.
1.4 Estrutura do Trabalho
No capítulo 2, apresentaremos uma introdução sobre computação em nuvens, e suas
características de serviços, como IaaS, PaaS e SaaS.
No capítulo 3, será apresentado o Google App Engine, e também uma comparação com o
serviço da Amazon.
No capítulo 4, será apresentado como configurar o Eclipse para o desenvolvimento de uma
aplicação com GAE, além de mostrarmos os passos para o desenvolvimento de uma aplicação
simples e deploy nas nuvens.
Capítulo 5, conclusão deste estudo, mostrando o que esperar da computação e nuvens e do
Google App Engine, além de ser apresentado os trabalhos futuros. No Apêndice, estará presente o
código fonte das principais classes do projeto, além do seu controle de versão.
10
2 Fundamentação Teórica
Para entender melhor como funciona o Google App Engine, é necessário ter uma base de
conhecimento sobre computação em nuvens. Este capítulo tem como objetivo apresentar os
conceitos de computação em nuvens, e suas principais características.
2.1 Computação em Nuvens
O termo computação em nuvens ou cloud computing surgiu 2006, em uma palestra de Eric
Schmidt, da Google. Computação em nuvens ou clomputing, se trata de usar a infraestrutura de
terceiras atrás da internet, o armazenamento, é feito com serviços que poderão ser acessados de
qualquer lugar do mundo a qualquer hora, atrás do acesso remoto via internet, daí a alusão a
nuvens. [4]
A palavra nuvem sugere uma ideia de ambiente desconhecido, o qual podemos ver apenas seu
início e fim, assim a palavra nuvem foi empregada a este novo conceito de tecnologia, pois toda a
infraestrutura computacional fica a cargo de terceiros, tendo o usuário final, acesso a estes recursos
e serviços.
As nuvens são representadas pela internet, que é a infraestrutura de comunicação dos recursos
disponibilizados de hardware, software, armazenamento, redes de telecomunicações e etc. Tudo isso
é possível, graças a grande informações de usuários armazenados em grandes centros chamados de
“data center”
Com a computação em nuvens, muitos aplicativos, não precisam mais estar instalados em
computadores do usuário final, nem mesmo em servidores e data centers próprio. Este conteúdo
fica disponível nas nuvens, ou seja, na internet. Cabendo ao fornecedor do serviço, todas as tarefas
de uma data center, como armazenamento, segurança, backups, atualizações e etc.
A computação em nuvem surge da necessidade de diminuir os gastos com recursos com
infraestrutura, e também da necessidade de se acessar os dados de qualquer lugar. Além disso,
recursos de computação e hardware são propensos a ficarem obsoletos rapidamente. Assim a
utilização de plataformas computacionais de terceiros é uma solução inteligente para os usuários
lidarem com a infraestrutura de TI, já que passa essa responsabilidade para o fornecedor contratado.
11
2.2 Características
A convergência de uma gama de importantes tecnologias permite à computação na nuvem
prover serviços de forma transparente para o usuário, dentre outras funcionalidades e
particularidades. Campos de tecnologia que são de grande relevância nesta convergência são:
Hardware, com a capacidade de virtualização, Tecnologias de internet, como a Web 2.0, serviços
web; Gerenciamento de Sistemas, como a computação independente(autonomic computing) e a
automação de gerenciamento e manutenção de Data Center; além da computação distribuída, em
especial a utility & grid computing. [1]
A computação na nuvem propicia a ilusão de recursos computacionais infinitos disponíveis para
o uso. Portanto, os usuários têm a expectativa de que a nuvem seja capaz de fornecer rapidamente
recursos em qualquer quantidade e a qualquer momento. É esperado que os recursos adicionais
possam ser providos, possivelmente de forma automática, quando ocorre o aumento da demanda e
retidos, no caso da diminuição desta demanda. [1]
O consumidor de serviços da computação na nuvem espera adquirir recursos computacionais de
acordo com sua necessidade e de forma instantânea. Para suportar este tipo de expectativa, as
nuvens devem permitir o acesso em autoatendimento (self-service) para que os usuários possam
solicitar, personalizar, pagar e usar os serviços desejados sem intervenção humana. [1]
Uma vez que o usuário tem a opção de requisitar e utilizar somente a quantidade de recursos e
serviços que ele julgar necessário, os serviços devem ser precificados com base em um uso de baixa
duração, como por exemplo, medido em horas de uso. Por esta razão, as nuvens devem implementar
recursos que garantam um eficiente comércio de serviços, tais como tarifação adequada,
contabilidade, faturamento, monitoramento e otimização do uso. Esta medição de uso dos recursos
deve ser feita de forma automática e de acordo com os diferentes tipos de serviços oferecidos
(armazenamento, processamento e largura debanda) e prontamente reportada, permitindo uma
maior transparência comercial. [3]
Os recursos devem estar disponíveis através da rede e acessados através de mecanismos padrões
que permitam a utilização dos mesmos por plataformas heterogêneas, como smartfones, laptops,
PDAs, entre outros. [2]
12
2.2.5 Customização
No atendimento a múltiplos usuários verifica-se a grande disparidade entre a necessidades dos
mesmos, tornando essencial a capacidade de personalização dos recursos da nuvem. Desde serviços
de infraestrutura, a serviços de plataforma e serviços de software.
2.3 Modelo de Serviço
O modelo conceitual encontrado na literatura é composto de três camadas, que definem um
padrão para computação em nuvem. Na ilustração 1, podemos verificar as camadas, informando
quem utiliza e o tipo de serviço.
Figura 1: Modelo de Serviço
2.3.1 Infraestrutura como Serviço – IaaS
Nesta camada são oferecidos os serviços de infraestrutura, ou seja, os fornecedores deste
serviço, oferecem recursos de hardwares virtualizados como computação, armazenamento e
comunicação. Está camada é a mais inferior, por este motivo, trabalha como infraestrutura para as
demais camadas.
Exemplo de ferramentas do nicho de serviço como infraestrutura é o Eucalyptus, um software
livre que consiste num framework que utiliza e gerência uma infraestrutura de computadores e
dispositivos de armazenamento com o intuito de disponibilizar um ambiente modular aos
13
prestadores de serviço. Outros exemplos estão o CloudSim (voltado para simulações), Amazon
Elastic Compute Cloud, que é puramente comercial, onde ele provê um ambiente virtual no qual é
possível desenvolver e executar aplicações Linux, para isso o usuário escolhe como sua máquina
virtual deve ser.[3]
2.3.2 Plataforma como serviço – PaaS
O fornecedor oferece um ambiente como serviço, onde pode ser desenvolvido aplicações nas
nuvens, evitando assim algumas preocupações dos desenvolvedores, como processamento e
quantidade de memória utilizada pela aplicação. É a camada intermediaria, e utiliza a camada
inferior para prover seus serviços.
A tecnologia que apresentaremos neste trabalho, o Google App Engine, faz parte desta camada
da computação em nuvens, ela oferece serviços capazes de desenvolver aplicações em Java, Python
ou qualquer outra linguagem de programação, que utilize uma Java Virtual Machine (JVM) ou
Máquina Virtual Java.
2.3.3 Software como Serviço – SaaS
Se trata da camada mais alta da computação e nuvens, e fornece como serviços, aplicações
completas para o usuário final. Essas aplicações são fornecidas através do acesso a Web, permitindo
a execução de programas nas nuvens, através de uma máquina local. O SaaS como camada mais
alta, utiliza o IaaS e PaaS para seus serviços.
O Google com seu Google App, é o mais famoso fornecedor deste serviço, entre os serviços
fornecidos, estão Gmail, Hangout e Google Docs, outros exemplos são o Microsoft Azure, Chrome
OS, Photoshop online e etc.
2.3.4 Demais serviços
Existem outras tipologias de computação em nuvem, tais como, DaaS (Desenvolvimento como
Serviço), CaaS (Comunicação como Serviço), TaaS (Teste como Serviço) e EaaS (Tudo como
Serviço). Utilizados normalmente para diferenciar um tipo de serviço.
14
2.4 Modelo de Implantação
No modelo de implantação,4 dependemos das necessidades das aplicações que serão
implementadas. A restrição ou abertura de acesso depende do processo de negócios, do tipo de
informação e do nível de visão desejado. Percebemos que certas organizações não desejam que
todos os usuários possam acessar e utilizar determinados recursos no seu ambiente de computação
em nuvem. Segue abaixo a divisão dos diferentes tipos de implantação [5].
2.4.1 Privado
Nuvens privadas, são aquelas construídas para um único usuário, por exemplo, uma empresa.
Nela o acesso é restrito, estabelecido pelo usuário, porém por ser uma nuvem privada que permite o
usuário ter este tipo de controle, gera um custo maior.
Característica que diferencia as nuvens privadas é ato da restrição de acesso, pois a mesma se
encontra atrás do firewall da empresa, sendo uma forma de aderir à tecnologia, beneficiando-se das
suas vantagens, porém mantendo o controle do nível de serviço e aderência às regras de segurança
da instituição. [4]
As nuvens privadas são aquelas construídas exclusivamente para um único usuário (uma
empresa, por exemplo). Diferentemente de uma data center privado virtual, a infraestrutura utilizada
pertence ao usuário, e, portanto, ele possui total controle sobre como as aplicações são
implementadas na nuvem. Uma nuvem privada é, em geral, construída sobre um Data
Center privado [5].
A figura 2, mostra um modelo de nuvem privada:
15
Figura 2: Modelo de Nuvem Privada
2.4.2 Pública
As nuvens públicas são aquelas que são executadas por terceiros. As aplicações de diversos
usuários ficam misturadas nos sistemas de armazenamento, o que pode parecer ineficiente a
princípio. Porém, se a implementação de uma nuvem pública considera questões fundamentais,
como desempenho e segurança, a existência de outras aplicações sendo executadas na mesma
nuvem permanece transparente tanto para os prestadores de serviços como para os usuários [5].
A figura 3, mostra um modelo de Nuvem publica.
16
Figura 3: Nuvem Pública
2.4.3 Comunidade
A infraestrutura de nuvem é compartilhada por diversas organizações e suporta uma
comunidade específica que partilha as preocupações (por exemplo, a missão, os requisitos de
segurança, política e considerações sobre o cumprimento). Pode ser administrado por organizações
ou por um terceiro e pode existir localmente ou remotamente [5].
A figura 4, mostra um modelo de Nuvem Comunitária
Figura 4: Nuvem Comunitária
2.4.4 Hibrido
Nas nuvens híbridas temos uma composição dos modelos de nuvens públicas e privadas. Elas
permitem que uma nuvem privada possa ter seus recursos ampliados a partir de uma reserva de
recursos em uma nuvem pública. Essa 8 característica possui a vantagem de manter os níveis de
17
serviço mesmo que haja flutuações rápidas na necessidade dos recursos. A conexão entre as nuvens
pública e privada pode ser usada até mesmo em tarefas periódicas que são mais facilmente
implementadas nas nuvens públicas, por exemplo. O termo “computação em ondas” é, em geral,
utilizado quando se refere às nuvens híbridas [3].
Na figura 5, temos um exemplo de Nuvem Hibrida
Figura 5: Nuvem Hibrida
2.5 Google App Engine
O Google App Engine, permite que os usuários executem os aplicativos na infraestrutura da
Google, assim não é necessário manter servidores, e se preocupar com os gastos que uma estrutura
dessas demandaria. O aplicativo é enviado para nuvens, e está pronto para ser utilizado pelo usuário
final.
Você pode enviar o arquivo para infraestrutura da Google, e manter seu próprio domínio, ou
também pode estar utilizando um nome livre de domínio oferecido pelo próprio Google App, o
appspot.com. O aplicativo enviado para o ambiente da Google, pode ser configurado para ser
acessado apenas por sua organização, ou ter livre acesso.
Os aplicativos podem ser desenvolvidos nas linguagens de programação Java e Python, ou por
qualquer outra linguagem de programação, que utilize uma Máquina Virtual Java. Para auxiliar no
desenvolvimento, é disponibilizado um conjunto de ferramentas chamado Google Web Toolkit
18
(GWT), que podem ser adicionados as principais IDEs do mercado, por exemplo, Eclipse e
Netbeans.
Na figura 6, mostra como funciona o ambiente de desenvolvimento em Java, e que existem
serviços de apoio.
Figura 6: Ambiente de desenvolvimento
Java
2.5.1 Funcionalidades do GAE
O Google App Engine facilita a criação de aplicativos que podem ser executados de forma
confiável mesmo sob uma carga pesada e com grandes quantidades de dados. O Google App Engine
inclui os seguintes recursos:
1.
Serviço da web dinâmico, com suporte completo a tecnologias da web comuns
2.
Armazenamento persistente com consultas, classificação e transações
3.
Escalonamento e balanceamento de carga automática
4.
APIs para autenticação de usuários e envio de e-mails usando Contas do Google
5.
Um ambiente de desenvolvimento local com todos os recursos, simulando o Google App
Engine em seu computador
6.
Filas de tarefas para realizar trabalho fora do escopo de uma solicitação da web
19
7.
Tarefas programadas para iniciar eventos em horários específicos e em intervalos regulares
O aplicativo pode ser executado em um destes dois runtime environments: Java e Python Cada
ambiente oferece protocolos padrão e tecnologias comuns para o desenvolvimento de aplicativos da
web. [6]
Os aplicativos são executados em um ambiente seguro que fornece acesso limitado ao sistema
operacional subjacente. Essas limitações permitem que o Google App Engine distribua solicitações
de web para o aplicativo entre diversos servidores, iniciando e interrompendo servidores para
atender às demandas de tráfego. O sandbox isola o aplicativo em seu próprio ambiente seguro e
confiável, independentemente de hardware, sistema operacional e localização física do servidor da
web.
São exemplos das limitações do ambiente seguro sandbox:
1.
Um aplicativo pode acessar outros computadores na Internet somente por meio dos serviços
de busca de URL e de e-mail fornecidos. Outros computadores podem se conectar ao aplicativo
somente fazendo solicitações HTTP (ou HTTPS) nas portas padrão.
2.
Um aplicativo não pode gravar no sistema de arquivos. Um aplicativo pode ler arquivos,
mas somente os enviados junto com o código do aplicativo. O aplicativo deve usar o
armazenamento de dados, o memcache ou outros serviços do Google App Engine para todos os
dados que persistirem entre solicitações.
3.
O código do aplicativo é executado somente em resposta a uma solicitação da web, a uma
tarefa na fila ou a um trabalho do cron, e deve retornar dados de resposta em 30 segundos,
independentemente do caso. Um manipulador de solicitação não pode gerar um subprocesso nem
executar o código após o envio da resposta. [6]
O Google App Engine, contém um mecanismos de armazenamento de dados distribuído,
baseado em consultas e transações. Assim o armazenamento de dados distribuído, cresce a medida
que o número de dados aumentam.
O armazenamento de dados do Google App Engine, não é de maneira relacional, como grande
parte dos bancos de dados presentes do mercado. As consultas do modelo oferecido pelo Google,
recupera uma entidade de um tipo determinado, filtradas e classificadas de acordo com as
propriedades definidas. As interfaces de Java JPA/JDO e as interfaces de armazenamento de dados
em Python, possuem recursos para implementação em seus aplicativos.
As consultas são executadas sobre objetos de dados, que também são conhecidas como
entidades, as entidades podem conter uma ou várias propriedades onde uma delas é um
identificador único chamado de chave.
O Google App Engine suporta a integração de um aplicativo com as Contas do Google para
20
autenticar um usuário. Seu aplicativo pode permitir que um usuário faça login com uma conta do
Google e acesse o endereço de e-mail e o nome de exibição associado à conta. O uso de Contas do
Google permite que o usuário comece a usar seu aplicativo mais rapidamente, pois talvez não
precise criar uma conta. Isso economiza o esforço de implementar um sistema de contas de usuário
somente para seu aplicativo.
Se seu aplicativo estiver sendo executado no Google Apps, ele pode usar os mesmos recursos
com os membros de sua organização e contas do Google Apps.
A API de usuários também pode informar ao aplicativo se o usuário atual é um administrador
registrado do aplicativo. Isso facilita a implementação de áreas de seu site restritas a
administradores. [6]
Criar um aplicativo no Google App Engine é gratuito, assim é possível desenvolver um
aplicativo e publicar o mesmo na plataforma do Google, sem nenhum custo inicial. Porém a versão
gratuita tem suas limitações, um aplicativo nesta categoria, pode ter apenas 500 MB de capacidade
de armazenamento, e 5 milhões de visualizações de página por mês. Caso necessite de mais
recursos, você pode ativar o faturamento, e escolher um dos planos disponíveis.
Você pode registrar no máximo 10 aplicativos por conta de desenvolvedor, e definir uma
limitação para cada um deles, as chamadas cotas, que define a quantidade de recursos que se pode
usar em um dia, podendo ser configurado posteriormente para aumentar ou até mesmo diminuir está
quantidade de recursos, a medida que seu aplicativo necessite.
2.6 Amazon Web Services (AWS)
Criado em 2006, o Amazon Web Services (AWS), começou a oferecer seus serviços de
computação em nuvens para as empresas de TI. Atualmente o AWS oferece nas nuvens um serviço
de infraestrutura altamente confiável e escalável, presente em mais de 190 pais, com seus Data
centers localizados nos EUA, Europa, Brasil, Cingapura, Japão e Austrália.
2.6.1 Funcionalidades do AWS Elastic Beanstalk
Assim que um aplicativo estiver sendo executado, o Elastic Beanstalk fornecerá vários recursos
de gestão, como:
21
1. Implemente facilmente as novas versões do aplicativo em ambientes em execução (ou
implante em uma versão anterior).
2. Acesse métricas de monitoramento CloudWatch embutidas, como a utilização média da
CPU, a contagem de solicitações e a latência média.
3. Receber notificações por e-mail por meio do Amazon Simple Notification Service (Amazon
SNS) quando o status do aplicativo mudar ou os servidores do aplicativo forem adicionados
ou removidos.
4. Acesse arquivos de log do servidor sem precisar efetuar login nos servidores do aplicativo.
5. Reiniciar rapidamente os servidores do aplicativo em todas as instâncias do EC2 com um
único comando.
Com o Elastic Beanstalk, os desenvolvedores retêm o controle total sobre os recursos da AWS
capacitando seu aplicativo e podem desempenhar uma série de funções simplesmente ao ajustar
definições de configuração padrão do console de gestão do Elastic Beanstalk, incluindo:
1. Seleção do tipo de instância do Amazon EC2 mais apropriado que corresponde aos
requisitos da CPU e de memória do seu aplicativo
2. Escolher entre várias opções de armazenamento e de banco de dados disponíveis, como o
Amazon RDS, Amazon DynamoDB, Amazon SimpleDB, Microsoft SQL Server, Oracle,
IBM DB2 ou o Informix.
3. Habilitação do acesso de login a instâncias do Amazon EC2 para a solução de problemas
imediata e direta
4. Aprimoramento rápido da confiabilidade do aplicativo ao executar em mais de uma Zona de
disponibilidade
5. Aperfeiçoamento da segurança do aplicativo ao habilitar o protocolo HTTPS no load
balancer
6. Ajustar configurações de servidor do aplicativo (p.ex., configurações JVM) e varáveis de
ambiente de passagem
7. Execução de outros componentes do aplicativo, como serviço de armazenamento em cache
da memória, lado a lado no Amazon EC2
8.
Ajustar as definições de Auto Scaling para controlar a métrica e os limites usados para
determinar quando adicionar ou remover instâncias de um ambiente. [7]
22
2.7 GAE x AWS
Apesar das duas tecnologias de computação em nuvens pertencerem a mesma camada, o PaaS,
ambas tem suas particularidades e similaridades que apresentaremos neste trabalho. Focaremos na
comparação referente a linguagem de programação Java, não entrando em detalhes nas demais
linguagens.
2.7.1 Ambiente de Desenvolvimento
Ambas as tecnologias possuem ferramentas que auxiliam o desenvolvimento, e também no
envio das aplicações para as nuvens, no caso da linguagem Java, possuem uma SDK que suporta o
Java 5 e 6.
Existe um Plug-in de desenvolvimento para a IDE Eclipse, o Google Web Toolkit (GWT) e
AWS Toolkit, após instalação do mesmo, sua IDE Eclipse, estará configurada para o criar, testar e
enviar suas aplicações para as nuvens.
O Netbeans, outra importante IDE do mercado, também possui um Plug-in de desenvolvimento
para o SDK, porém o Eclipse é mais recomendado, e citado na documentação de ambas as
tecnologias.
2.7.2 Armazenamento
O Google App Engine inclui suporte a dois padrões de APIs diferentes para o armazenamento
de dados: JDO (Objetos de dados Java) e JPA (API persistente Java). Essas interfaces são oferecidas
pelo DataNucleus Access Platform, uma implementação de código aberto de vários padrões de
persistência Java, com um adaptador para o armazenamento de dados do App Engine. [6]
Criado e oferecido pelo Google, o BigTable é um banco de dados orientando a colunas, salva
objetos de dados, conhecidos como entidades. Uma entidade tem uma ou mais propriedades, valores
nomeados de um dos vários tipos de dados, incluindo números inteiros, valores de ponto flutuante,
strings, datas, dados binários e etc. Cada entidade também tem uma chave que identifica a entidade.
A chave mais simples têm um tipo e um ID de entidade fornecidos pelo armazenamento de dados. O
tipo classifica a entidade para que você possa consultá-la com mais facilidade. O ID da entidade
também pode ser uma string fornecida pelo aplicativo. Ao contrário de banco de dados tradicionais,
o armazenamento de dados usa uma arquitetura distribuída, também é diferente na forma como
23
descrever relacionamentos entre objetos de dados, com o BigTable duas entidades do mesmo tipo,
podem ter propriedades diferentes. Diferentes entidades de dados podem ter propriedades com o
mesmo nome, mas tipos de valores diferentes.
São usadas consultas escritas em Google Query Language (GQL) para recuperar dados do
BigTable, diferente dos bancos de dados tradicionais que utilizam Structured Query Language
(SQL). Caso o desenvolvedor queria utilizar o MySQL, banco de dados modelo relacional mais
utilizado no mundo, é necessário uma outra ferramenta do Google, chamada Google Cloud SQL
que pode ser integrada ao Google App Engine.
O Amazon Elastic Beanstalk, o usuário pode utilizar qualquer um dos bancos relacionais mais
populares do mercado, como MySQL, Oracle e Microsoft SQL, basta utilizar um dos seus serviços
de persistência chamado Amazon RDS. Outros serviços oferecidos pela Amazon, são: O Amazon
DynamoDB é um serviço de banco de dados NoSQL, Amazon SimpleDB é um serviço de banco de
dados NoSQL gerenciado, projetado para conjuntos de dados menores e Amazon ElastiCache é um
serviço web que trabalha com cache na memória na nuvem.
2.7.3 Definição de Preços e Limites
Ambos os serviços apresentados, oferecem opções gratuitas para serem utilizadas, e o
contratante só paga o que exceder este limite gratuito. No caso do Google App Engine, um
aplicativo de uma conta gratuita pode usar até 500 MB de armazenamento e até 5 milhões de
visualizações de página por mês. Além disso, você pode registrar até 10 aplicativos por conta de
desenvolvedor.
Amazon Elastic Beanstalk, você só paga pelos recursos AWS subjacentes, por exemplo, um
recurso mais robusto de armazenamento. Cada recurso do AWS, também possui sua cota gratuita,
que varia de produto para produto. Entretanto, o custo é alto para Web sites com tráfego baixo e
desenvolvedores amadores. É possível criar até 25 aplicativos e 500 versões de aplicativos. Por
padrão, você pode executar até 10 ambientes em todos seus aplicativos.
2.7.4 Plataforma Java
Google App Engine e Amazon Elastic Beanstalk, possuem suporte para a Plataforma Java, nas
24
versões 5 e 6, entretanto há algumas diferenças entre os dois serviços. No caso do primeiro, os
recursos para Java são limitados, e em alguns casos fora dos padrões. Devido a várias restrições
impostas aos seus aplicativos, o Google App Engine não suporta certas APIs da plataforma Java.
As limitações de APIs, acaba prejudicando o uso de alguns frameworks famosos no mercado,
podemos usar como exemplo, o JavaServer Faces (JFS), que requer modificações manualmente no
código de origem do framework para fazer com que ele execute no Google App Engine.
Amazon Elastic Beanstalk, suporta servidor Tomcat completo. Por causa de sua popularidade,
quase todos os frameworks Java corporativos suportam a implementação em Tomcat. Esses
frameworks podem ser iniciados ou inicializados a partir de um arquivo WAR do Tomcat,
oferecendo a você uma ampla variedade de opções de frameworks e bibliotecas.
25
3 Aplicação com Google App Engine
O objetivo deste trabalho, é apresentar a estrutura de desenvolvimento da ferramenta do Google,
além do apresentarmos o desenvolvimento de uma aplicação simples. Após o desenvolvimento, a
aplicação será envidada para as Nuvens.
3.1 Preparando o Ambiente
Para o desenvolvimento da aplicação, precisamos preparar o ambiente, além do Java e da IDE
Eclipse, precisaremos do SDK do Google App Engine.
O SDK inclui software para um servidor web que você pode executar no seu próprio
computador para testar seus aplicativos Java. O servidor simula todos os serviços do App Engine,
incluindo uma versão local do armazenamento de dados, Contas do Google e recursos de busca de
URLs e envio de e-mails pelo computador através das APIs do App Engine. [6]
3.1.1 Java Development Kit
Java Development Kit é um conjunto de utilitários que permitem criar sistemas de software para
plataforma Java. O Google App Engine, tem suporte para as versões 5 e 6, e também suporte
experimental para a versão 7. A versão recomendada para o desenvolvimento de suas aplicações, é a
6.
É necessário realizar o download do JDK para instalação, isso pode ser feito no site do
fornecedor. A instalação depende do sistema operacional utilizado, mas instruções de instalação
podem ser encontrados em: http://docs.oracle.com/javase/7/docs/webnotes/install/index.html
Depois que o JDK estiver instalado, execute os seguintes comandos em um prompt de comando,
java -version e javac -version para confirmar se é possível executar os comandos e para identificar a
versão instalada. Como mostra a figura 7.
26
Figura 7: Verificando instalação do Java
3.1.2 Plug-in do Google para IDE Eclipse
Google Web Toolkit (GWT) é um Plug-in do Google para Eclipse que ajuda no
desenvolvimento de aplicações. O Plug-in permite que você crie, teste e envie aplicativos do App
Engine pelo Eclipse.
Você pode instalar o Plug-in usando o recurso Software Update (Atualização de software) do
Eclipse, instalaremos a versão para a última versão do Eclipse no momento, Eclipse 4.3 (Kepler).
Com o Eclipse aberto, selecione Help (Ajuda) > Install New Software... (Instalar novo software...).
Irá abrir uma janela para informarmos o Plug-in que deve ser instalado, conforme figura número 8.
Figura 8: Adicionando o link do Plug-in
27
Na janela da figura 8, devemos clicar em “Add” para adicionar o nome e o endereço, de onde o
Eclipse
deve
baixar
o
Plug-in.
O
endereço
que
dever
ser
inserido:
https://dl.google.com/eclipse/plugin/4.3 conforme a figura 9.
Figura 9: Adicionando nome e endereço do Download
Após o endereço ser adicionado, uma lista de ferramentas do Google App Engine, será
mostrada. Para o desenvolvimento de aplicações Web, é necessário apenas as opções requeridas e
recomendadas, mas adicionaremos todas as ferramentas, como mostra a figura 10.
Figura 10: Escolhendo as ferramentas
28
A próxima janela que será aberta, mostra os detalhes dos recursos que serão instalados, bastando
clicar em “Next”, como mostra a figura 11.
Figura 11: Detalhes dos recursos
A figura 12, mostra o processo de instalação, que pode levar alguns minutos.
Figura 12: Processo de instalação
29
3.1.3 Testando a instalação
Com a instalação concluída, para testar se tudo está funcionando, pode executar uma das várias
aplicações demos inclusos no SDK Java do App Engine. Se você usa o Eclipse, o SDK estará
localizado
no
diretório
de
instalação,
em
plugins/com.google.appengine.eclipse.sdkbundle_VERSION/, em que VERSION representa o
identificador de versão do SDK.
Para testar a instalação e executar um dos aplicativos demos, uma das opções é usar a linha de
comando, para isso, acesse a pasta do Plug-in no Eclipse, e execute o comando, como mostra as
ilustrações 13 e 14:
Se estiver usando o Mac OS X ou o Linux, execute o seguinte comando:
Figura 13: Comando para Linux e MAC OS, [6]
Se estiver usando o Windows, execute o seguinte comando:
Figura 14: Comando para Windows, [6]
3.2 Criando o primeiro Projeto
Os aplicativos Java do App Engine usam a norma Java Servlet para interagir com o ambiente do
servidor web. Os arquivos de um aplicativo, incluindo classes compiladas, JARs, arquivos estáticos
e de configuração, são organizados em uma estrutura de diretórios no layout padrão WAR para
aplicativos web Java. Você pode usar qualquer processo de desenvolvimento que desejar para
desenvolver servlets web e criar um diretório do WAR. Os arquivos do armazenamento WAR ainda
não são compatíveis com o SDK. [GOOGLE, 2013]
No Eclipse, crie um novo projeto, clicando no botão Web Application Project New na barra de
ferramentas: O botão Web Application Project New:
De um nome para o projeto, e um nome
30
para o pacote do mesmo, clique em finalizar, e será criado um novo projeto com a estrutura
mostrada na figura 15.
Figura 15: Estrutura do Projeto
•
src: Código fonte Java;
•
META-INF: Outras configurações;
•
war: JSP, imagens e arquivos de dados;
•
WEB-INF: Aplicativos de configuração;
•
lib: JARs, onde adicionamos as bibliotecas;
•
classes: Classes compiladas.
3.2.1 Olá Mundo
Os aplicativos em Java do App Engine usam a API Java Servlet para interagir com o servidor
web. Um servlet HTTP é uma classe de aplicativo que pode processar e responder a solicitações da
web.
Essa
classe
estende
javax.servlet.http.HttpServlet. [6]
a
classe
javax.servlet.GenericServlet
ou
a
classe
31
Crie um Servlet dentro do diretório “src” com o código mostrado na figura 16.
Figura 16: Olá Mundo
Após o desenvolvimento do código, execute aplicação em Run > Run As > Web Application.
Eclipse e o Plug-in do Google para Eclipse, o servidor será executado pela porta 8888 por padrão,
como mostra a figura 17.
Figura 17: Execução do Olá Mundo
32
3.3 Mural de Mensagens
O projeto demostrativo deste trabalho, será um Mural de mensagens, onde poderá ser postada
uma mensagem e a mesma será gravada no mural através da persistência utilizando JDO. O usuário
que estiver logado em uma conta do Google, aparecerá seu nome na mensagem, caso contrário, será
postado como anônimo.
3.4 Persistência
O Google App Engine, permite que realize persistência usando duas API Java. O JDO (Objeto
de dados Java) e JPA (API de persistência Java), no exemplo proposto deste trabalho, será utilizada
a primeira API citada.
3.4.1 DataNucleus Access Platform
O Access Platform precisa de um arquivo de configuração que especifique que ele usará o
armazenamento de dados do GAE, este arquivo é chamado jdoconfig.xml. E deve estar no diretório
war/WEB-INF/classes/META-INF/. Caso esteja utilizando o Eclipse com o Plug-in do Google App
Engine, este arquivo deve ser gerado automaticamente, caso o contrário, crie um com as
informações mostradas na figura 18.
Figura 18: Configurações JDO
33
3.4.2 Anotações JDO e POJOs
Devemos agora criar um POJO(Plain Old Java Objects), simples classes Java, com construtor e
Gets e Sets. Porém nestas classes adicionaremos anotações JDO para que possamos persisti-la na
plataforma da Google.
Para declarar uma classe Java como capaz de ser armazenada e recuperada do armazenamento
de dados com JDO, atribua a anotação @PersistenceCapable à classe. [6].
Campos da classe de dados que devem ser armazenados no armazenamento de dados devem ser
declarados como campos persistentes. Para declarar um campo como persistente, dê a ele uma
anotação @Persistent. [6]
Toda a classe deve conter um campo dedicado para a chave primaria, As chaves principais
exigem
uma
anotação
@PrimaryKey
e
uma
IdGeneratorStrategy.IDENTITY).
A figura 19, mostra um exemplo de classe anotada.
Figura 19: Classe com anotação JDO
anotação
@Persistent(valueStrategy
=
34
3.4.3 Fábrica de Conexão e persistence.xml
Cada solicitação que usa o armazenamento de dados cria uma instância nova da classe
PersistenceManager. Para fazer isso, ela usa uma instância da classe PersistenceManagerFactory.
Uma instância da PersistenceManagerFactory demora para ser inicializada. Felizmente, você só
precisa de uma instância para seu aplicativo e ela pode ser armazenada em uma variável estática
para ser usada por várias solicitações e várias classes. Uma maneira fácil de fazer isso através da
criação de uma única classe empacotadora para a instância estática.[6]
As figuras 20 e 21 ilustram nosso modelo de fábrica de conexão e persistência.
Figura 20: Exemplo de fábrica de conexão
O transactions-optional deve estar em seu persistence.xml:
35
Figura 21: persistence.xml
3.4.4 Servlet
A classe BtajdoServlet será responsável por criar e persistir nosso objeto. Para salvar a instância
no
armazenamento
de
dados,
ele
cria
um
PersistenceManager
usando
um
PersistenceManagerFactory e, em seguida, passa a instância para o método makePersistent() do
PersistenceManager. Depois que makePersistent() retorna, o novo objeto é armazenado no
armazenamento de dados.
A figura 22, ilustra nosso modelo.
36
Figura 22: Servlet
3.4.5 View (JSP)
Após a criação do Servlet devemos criar nossa JSP, que será responsável por mostrar as
informações no navegador do usuário, nossa visão deve ser editada com as informações que deseja
apresentar. A figura 23, ilustra nosso formulário.
Figura 23: JSP
3.4.6 JDOSQL
37
A norma JDO define um mecanismo para consultar objetos persistentes chamadas JDOQL. Você
pode usar o JDOQL para realizar consultas de entidades no armazenamento de dados do App
Engine e recuperar resultados como objetos aprimorados pelo JDO.
Realize uma consulta com a interface JDO através da JDOQL, uma linguagem de consultas do
tipo SQL para recuperação de objetos de dados. A linha a seguir define a sequência de caracteres da
consulta JDOQL. [6]
Um exemplo de consulta com JDOSQL pode ser visto na figura 24.
Figura 24: Exemplo de JDOSQL
3.4.7 Como enviar o projeto com a IDE Eclipse
Depois de pronto, para enviar o projeto para a plataforma da Google, é necessário criar um ID
único para o projeto, após a criação deste ID, temos a possibilidade de excluirmos, porém, não
poderemos usar o mesmo ID novamente.
Para criar o ID do projeto, acesse a URL: https://appengine.google.com/ . Será necessário ter
uma conta Google, caso não possua, a mesma pode ser criada preenchendo o formulário da URL:
https://accounts.google.com/SignUp?service=chromiumsync&continue=https%3A%2F
%2Fwww.google.com%2Fintl%2Fpt-BR%2Fchrome%2Fblank.html%3Fsource%3D1
Como mostra a figura 25.
38
Figura 25: Criando uma conta Google
Após finalizar a criação da conta Google, para criar o ID do projeto, clique em “Create
Application” e preenchendo os campos do formulário, como mostra as figuras 26 e 27.
Figura 26: Criando o ID do Projeto
Figura 27, vemos o formulário que deve ser preenchido.
39
Figura 27: Formulário do ID
No projeto edite o arquivo appengine-web.xml e, em seguida, altere o valor do elemento
<application> para corresponder ao ID de aplicativo que registrou. O arquivo deve estar na pasta
WEB-INF de sua aplicação.
A figura 28, mostra onde devemos adicionar o ID no projeto.
Figura 28: Adicionando o ID no Projeto
Pode enviar o código e os arquivos do projeto pelo Eclipse usando o Plug-in do Google. Para
enviar o projeto pelo Eclipse, clique no botão de implementação do App Engine na barra de
40
ferramentas:
.
Quando solicitado, digite o nome de usuário (seu endereço de e-mail) e a senha da Conta do
Google e, em seguida, clique no botão Enviar. O Eclipse coletará as informações de versão e ID do
aplicativo no arquivo appengine-web.xml e enviará os conteúdos do diretório war/. [6]
A figura 29, mostra o processo de envio do projeto no Eclipse.
Figura 29: Enviando o projeto
Em seguida, será aperto uma janela com o projeto já rodando na plataforma da Google, como
mostra a figura 30.
41
Figura 30: Projeto mural de mensagens
42
4 Conclusão
Este trabalho apresentou o que é, e como desenvolver aplicações para o Google App Engine.
Seus recursos também foram comparados com outro concorrente do mercado, assim foi possível
observar as vantagens e desvantagens de cada serviço.
O projeto final foi criado e adicionado na plataforma do Google, o mesmo seguiu os passos
propostos pela própria documentação oficial, e funcionou de acordo com o propósito apresentado
neste trabalho.
As configurações para chegarmos neste ponto, não são complicadas, a IDE Eclipse ajuda
bastante neste quesito, evitando que seja necessário recorrer ao terminal e a linha de comando, que
embora sejam efetivos, é mais sugestivo ao erro.
Na implementação do código fonte, nota-se que para desenvolver para o Google App Engine, é
necessário seguir algumas regras propostas pela tecnologia, principalmente para manter a
escalonamento do projeto. Estas regras acabam deixando o desenvolvimento mais engessado,
evitando que todo o poder das APIs Java sejam utilizadas. Neste ponto, o Elastic Beanstalk, da
Amazon, leva vantagem, pois pode utilizar todo o poder das APIs, porém o mau uso delas, pode
atrapalhar o escalonamento do projeto.
O deploy do projeto, mais uma vez é facilitado pela ajuda da IDE Eclipse, com o auxílio da
ferramenta, o projeto é enviado apenas com alguns poucos passos que deve ser tomados para evitar
problemas no envio.
Ferramenta para o desenvolvimento são oferecidas, e facilitam muito para a criação do projeto,
com a ajuda do Plug-in da Google, o desenvolvedor pode focar mais no projeto, deixando parte de
configurações para a Plug-in. Também é oferecido um framework o Google Tool Kit, que agiliza
ainda mais o desenvolvimento. Caso seja necessário, a ferramenta ainda pode ser utilizada através
da linha de comando, onde se mostra proporcionalmente efetivo.
Já na plataforma do Google App Engine, mesmo sendo um conta de limite gratuito, o projeto
apresentou bom desempenho, e sempre disponível para utilização do mesmo. Mostrando que é um
serviço confiável.
Computação em nuvens está se tornando cada vez mais presente, e Google junto com a
Amazon, foram pioneiras no assunto, e hoje apresentam diversas tecnologias e recursos para
computação em nuvens, e saem na frente neste quesito,
43
Como trabalho futuro, pode ser realizado um projeto utilizando os serviços da Amazon, e
realizar o deploy na infraestrutura oferecida, assim podemos comparar o desempenho e cada uma
das tecnologias, também poderá ser visto o desempenho da IDE Eclipse com o Plug-in oferecido
pela ferramenta Elastic Beanstalk.
44
5 Referência bibliográfica
[1] Pedrosa, Paulo H. C. e Tiago Nogueira. Computação em nuvens. Disponível em
<http://www.ic.unicamp.br/~ducatte/mo401/1s2011/T2/Artigos/G04-095352-120531-t2.pdf>.
Acessado em 10 out 2013 Apud BUYYA, Rajkumar; BROBERG, James; GOSCINSKI, Andrzej.
Cloud Computing Principles and Paradigms; 1. ed New Jersey, U.S. : John Wiley & Sons, Inc.
2011. 664p. ISBN: 978-0-470-88799-8
[2] Pedrosa, Paulo H. C. e Tiago Nogueira. Computação em nuvens. Disponível em
<http://www.ic.unicamp.br/~ducatte/mo401/1s2011/T2/Artigos/G04-095352-120531-t2.pdf>.
Acessado em 10 out 2013 Apud MELL, Peter; GRANCE, Timothy. The NIST Definition of Cloud
Computing (Draft). January 2011.
[3] Pedrosa, Paulo H. C. e Tiago Nogueira. Computação em nuvens. Disponível em
<http://www.ic.unicamp.br/~ducatte/mo401/1s2011/T2/Artigos/G04-095352-120531-t2.pdf>.
Acessado em 10 out 2013 Apud CHIRIGATI, Fernando Seabra. Computação em Nuvem. Rio de
Janeiro, RJ. 2009.
[4] Um estudo sobre os benefícios e os riscos de segurança na utilização de Cloud Computing.Fabrício
Rodrigues.
computing/>. Acessado
Disponível
em
<http://fabriciorhs.wordpress.com/2010/09/28/cloud-
em 15 nov 2013 Apud TAURION, C. Computação em Nuvem:
Transformando o mundo da tecnologia da informação. Rio de Janeiro: Brasport, 2009.
[5]
Cloud
Computing.-
Fabrício
Rodrigues.
Disponível
em
<http://fabriciorhs.wordpress.com/2010/09/28/cloud-computing/>. Acessado em 15 nov 2013
[6] Google App Engine. Disponível em <https://developers.google.com/appengine/?hl=pt-BR>.
Acessado em 9 ago 2013.
[7] AWS Elastic Beanstalk. Disponível em <http://aws.amazon.com/pt/elasticbeanstalk/>.
Acessado em 9 ago 2013.
45
Apêndices
46
Apêndice A – Classe BtajdoServlet
package btajdo;
import java.io.IOException;
import java.util.Date;
import java.util.logging.Logger;
import javax.jdo.PersistenceManager;
import javax.servlet.http.*;
import com.google.appengine.api.users.User;
import com.google.appengine.api.users.UserService;
import com.google.appengine.api.users.UserServiceFactory;
@SuppressWarnings("serial")
public class BtajdoServlet extends HttpServlet {
private static final Logger log = Logger.getLogger(BtajdoServlet.class.getName());
public void doPost(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();
String content = req.getParameter("content");
Date date = new Date();
Mural mural = new Mural(user, content, date);
PersistenceManager pm = PMF.get().getPersistenceManager();
try {
pm.makePersistent(mural);
} finally {
pm.close();
}
47
resp.sendRedirect("/mural.jsp");
}
}
48
Apêndice B – Mural.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.List" %>
<%@ page import="javax.jdo.PersistenceManager" %>
<%@ page import="com.google.appengine.api.users.User" %>
<%@ page import="com.google.appengine.api.users.UserService" %>
<%@ page import="com.google.appengine.api.users.UserServiceFactory" %>
<%@ page import="btajdo.Mural" %>
<%@ page import="btajdo.PMF" %>
<html>
<head>
<title>BRUNO THEDORO DE AQUINO</title>
</head>
<body>
<h1>Trabalho Final - Bruno Theodoro de Aquino</h1>
<%
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();
if (user != null) {
%>
<p>Oi, <%= user.getNickname() %>! (você pode
<a href="<%= userService.createLogoutURL(request.getRequestURI()) %>">sair</a>.)</p>
<%
} else {
%>
<p>Oi!
<a href="<%= userService.createLoginURL(request.getRequestURI()) %>">Entre</a>
para incluir o seu nome</p>
<%
}
%>
<%
PersistenceManager pm = PMF.get().getPersistenceManager();
String query = "select from " + Mural.class.getName();
List<Mural> ms = (List<Mural>) pm.newQuery(query).execute();
if (ms.isEmpty()) {
%>
<p>O livro de visitas não tem mensagens.</p>
<%
} else {
for (Mural g : ms) {
if (g.getAuthor() == null) {
%>
<p>Uma pessoa anônima escreveu:</p>
<%
49
} else {
%>
<p><b><%= g.getAuthor().getNickname() %></b> escreveu:</p>
<%
}
%>
<blockquote><%= g.getContent() %></blockquote>
<%
}
}
pm.close();
%>
<form action="/sign" method="post">
<div><textarea name="content" rows="3" cols="60"></textarea></div>
<div><input type="submit" value="Poste no Mural" /></div>
</form>
<form action="/mural.jsp" method="get">
<!-- <div><input type="submit" value="Mudar Livro de Visitas" /></div> -->
</form>
</body>
</html>
50
Apêndice C – Controle de Versão com Git.
Instalando o Git
Acesse o link: http://git-scm.com/book/pt-br/Primeiros-passos-Instalando-Git.
O Git é multiplataforma, e está disponível para Linux, Windows e MacOS. Instale seguindo os
passos para o sistema operacional adequado, mostrado no link.
Criando um Repositório Online
Acesse o link: https://bitbucket.org/
Existe alguns serviços que oferecem Repositórios nas nuvens, onde é armazenado as versões do
projeto. Clique em Sign up for free para criar uma conta gratuita, como mostra a Figura 31.
Figura 31
Acessando o link para criar uma conta, é exibira a tela da Figura 32. Basta preencher os campos
solicitados e clicar no botão Sign Up.
51
Figura 32: Fonte: Bitbucket. 2013
Após se criar uma conta, acesse a mesma com usuário e senha, e clique no botão Criar, e será
exibida a tela da Figura 33, preencha os dados, e clique no botão Criar repositório novo repositório
online.
Figura 33: Fonte: Bitbucket. 2013
52
Criado o repositório, clique em Estou começando do zero, e siga os passos da Figura 34 para
criar uma pasta do seu repositório local, iniciar o controle de versão e sincronizar com seu
repositório nas nuvens.
Figura 34: Fonte: Bitbucket. 2013
Enviando o projeto para Repositório nas nuvens.
Com os repositórios criados, adicionar as mudanças, confirme as mudança e envie o projeto
para o repositório nas nuvens criado. A Figura 35, mostra os passos no terminal de comando.
53
Figura 35
A Figura 36, mostra o projeto já presente no repositório nas nuvens.
Figura 36: Fonte: Bitbucket, 2013