FACULDADE COMUNITÁRIA DE CAMPINAS – UNIDADE 2

CENTRO UNIVERSITÁRIO PADRE ANCHIETA
Curso de Sistemas de Informação
Análise da Plataforma de Desenvolvimento
Google App engine
EDUARDO PERNAMBUCO PESSINI – R.A. 0221426
JULIO CESAR GARÇON MARTINHO – R.A. 0955647
RAFAEL MARTINS MAZZOLA – R.A. 0954360
JUNDIAÍ, SP – 2012
Sumário
1. O QUE É O GOOGLE APP ENGINE?..................................................................3
2. O AMBIENTE DO APLICATIVO........................................................................4
3. O SANDBOX................................................................................................4
4. O JAVA RUNTIME ENVIRONMENT...................................................................5
5. O PYTHON RUNTIME ENVIRONMENT..............................................................6
6. O ARMAZENAMENTO DE DADOS....................................................................6
7. SERVIÇOS DO GOOGLE APP ENGINE..............................................................7
1.1
1.2
1.3
1.4
BUSCA DE URL: ................................................................................................................7
E-MAIL:............................................................................................................................8
MEMCACHE:.......................................................................................................................8
MANIPULAÇÃO DE IMAGENS: ...................................................................................................8
8. TAREFAS AGENDADAS E FILAS DE TAREFAS...................................................8
9. FLUXO DE DESENVOLVIMENTO.....................................................................9
10. COTAS E LIMITES.....................................................................................10
11. EXEMPLOS DE USO..................................................................................11
1.5 EARTH HOUR - HTTP://WWW.EARTHHOUR.ORG/............................................................................11
1.6 A CASA BRANCA (EUA) ABERTO PARA PERGUNTAS - HTTP://WWW.WHITEHOUSE.GOV/OPENFORQUESTIONS......11
1.7 JAIKU - HTTP://JAIKIDO.BLOGSPOT.COM.BR/2009/03/JAIKU-IS-NOW-SERVED-FROM-APP-ENGINE.HTML..............11
12. BIBLIOGRAFIA.........................................................................................12
1. O QUE É O GOOGLE APP ENGINE?
O Google App Engine é uma plataforma de Computação em nuvem para
desenvolver e hospedar aplicações web na infraestrutura do Google. Foi inicialmente
lançado como versão preliminar (beta) em Abril de 2008.
É uma tecnologia no modelo Plataforma como Serviço. Ele virtualiza aplicações em
múltiplos servidores, provendo hardware, conectividade, sistema operacional e
serviços de software. O Google App Engine pode ser usado gratuitamente até um
determinado nível de consumo de recursos. A partir daí, tarifas adicionais são
cobradas pelo consumo recursos (armazenamento, banda de rede, ciclos de CPU,
etc.)
da
aplicação.
Oferece
um
rápido
processo
de
desenvolvimento
e
implementação, administração simples, sem ser necessário se preocupar com
hardware, patches ou backups, e escalabilidade fácil. Com ele, não há necessidade
de manter servidores: você apenas envia seu aplicativo e ele está pronto para
atender a seus usuários.
O Google App Engine suporta aplicativos criados em várias linguagens de
programação. O ambiente de execução em Java do Google App Engine permite
criar um aplicativo usando tecnologias Java padrão, incluindo JVM, servlets Java e a
linguagem de programação Java, ou qualquer outra linguagem que usa um
interpretador ou compilador com base na JVM, como Java Script ou Ruby. Também
apresenta um Python runtime environment dedicado, que inclui um interpretador de
Python rápido e a biblioteca Python padrão, cuja criação teve a finalidade de garantir
que o aplicativo seja executado rapidamente, com segurança e sem interferência de
outros aplicativos no sistema.
Em relação a eventuais cobranças pela utilização de recursos adicionais, como
armazenamento e largura de banda, os valores são medidos em gigabytes e
cobrados a taxas competitivas, ficando por conta do usuário (desenvolvedor)
controlar a quantidade máxima de recursos que seu aplicativo pode consumir,
ficando dentro de seu orçamento.
Todos os aplicativos podem usar até 500 MB de armazenamento e CPU e largura de
banda suficiente para suportar um aplicativo eficiente que ofereça cerca de cinco
milhões de visualizações de página por mês, totalmente grátis. Ao ativar o
faturamento para o aplicativo, os limites gratuitos aumentam e o desenvolvedor paga
somente pelos recursos que ultrapassam os níveis gratuitos.
2. O AMBIENTE DO APLICATIVO
O Google App Engine inclui os seguintes recursos:
•
Serviço da web dinâmico, com suporte completo a tecnologias da
web comuns
•
Armazenamento
persistente
com
consultas,
classificação
e
transações
•
Escalonamento e balanceamento de carga automáticos
•
APIs para autenticação de usuários e envio de e-mails usando
Contas do Google
•
Ambiente de desenvolvimento local com todos os recursos,
simulando o Google App Engine em seu computador
•
Filas de tarefas para realizar trabalho fora do escopo de uma
solicitação da web
•
Tarefas programadas para iniciar eventos em horários específicos e
em intervalos regulares
O
aplicativo
pode
ser
environments: Java e Python.
executado
Cada
em
ambiente
um
oferece
destes
dois
protocolos
runtime
padrão
e
tecnologias comuns para o desenvolvimento de aplicativos da web.
3. O SANDBOX
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:
•
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.
•
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.
•
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.
4. O JAVA RUNTIME ENVIRONMENT
Pode-se desenvolver um aplicativo para o Java runtime environment usando
ferramentas comuns de desenvolvimento da web e padrões de APIs em Java. O
aplicativo interage com o ambiente usando o padrão servlet Java e pode usar
tecnologias comuns de aplicativos da web, como JSPs (JavaServer Pages).
O Java runtime environment usa Java 6. O SDK para Java do Google App Engine
suporta o desenvolvimento de aplicativos em Java 5 ou 6.
O ambiente inclui a plataforma JRE 6 (Java SE Runtime Environment) e suas
bibliotecas. As restrições do ambiente sandbox são implementadas na JVM. Um
aplicativo pode usar qualquer bytecode JVM ou recurso da biblioteca, contanto que
não exceda as restrições do sandbox.
Para o armazenamento de dados do Google App Engine, o SDK para Java inclui
implementações das interfaces JDO (Objetos de dados Java) e JPA (API persistente
Java). Seu aplicativo pode usar a API JavaMail para enviar mensagens de e-mail
com o serviço de e-mail do Google App Engine. As APIs HTTP java.net acessam o
serviço de busca de URL do Google App Engine. Os serviços do Google App Engine
também incluem APIs de nível inferior para programar adaptadores adicionais ou
para serem usadas diretamente do aplicativo.
5. O PYTHON RUNTIME ENVIRONMENT
Com o Python runtime environment do Google App Engine, é possível implementar o
aplicativo usando a linguagem de programação Python e executá-lo em um
interpretador otimizado de Python. O Google App Engine inclui APIs avançadas e
ferramentas para desenvolvimento de aplicativos da web em Python, incluindo uma
API de modelagem de dados avançada, uma estrutura para aplicativos da web de
fácil uso e ferramentas para gerenciar e acessar os dados de seu aplicativo.
O Python runtime environment usa a versão 2.5.2 de Python. Inclui a biblioteca
Python padrão. Nem todos os recursos da biblioteca podem ser executados no
ambiente do sandbox. O código dos aplicativos para o ambiente Python deve ser
criado exclusivamente em Python. Não há suporte para extensões criadas na
linguagem C.
O Google App Engine fornece uma estrutura Python simples de aplicativo da web
denominada webapp, para que você possa começar a criar aplicativos facilmente.
Pode-se também fazer upload de outras bibliotecas de terceiros com o aplicativo,
desde que elas sejam implementadas em Python puro e não exijam nenhum módulo
de biblioteca padrão não suportado.
6. O ARMAZENAMENTO DE DADOS
O Google App Engine fornece um poderoso serviço de armazenamento de dados
distribuído que contém um mecanismo de consultas e transações. Assim como o
servidor da web distribuído cresce proporcionalmente ao tráfego, o armazenamento
de dados distribuído cresce à medida que os dados aumentam.
O armazenamento de dados do Google App Engine não é um banco de dados
relacional tradicional. Objetos de dados, ou "entidades", têm um tipo e um conjunto
de propriedades. Consultas podem recuperar entidades de um tipo determinado,
filtradas e classificadas segundo os valores das propriedades. Os valores das
propriedades
podem
propriedade compatíveis.
ser
de
qualquer
um
dos tipos
de
valor
de
As entidades do armazenamento de dados não possuem esquema. A estrutura das
entidades de dados é fornecida e aplicada pelo código de aplicativo desenvolvido.
As interfaces Java JDO/JPA e a interface do armazenamento de dados em Python
incluem recursos para aplicar e implementar a estrutura em seu aplicativo. O
aplicativo também pode acessar o armazenamento de dados diretamente para
aplicar as mudanças necessárias.
O armazenamento de dados é altamente consistente e usa controle de concorrência
otimista. Uma atualização de entidade ocorre em uma transação com um número
fixo de tentativas, caso outros processos estejam tentando atualizar a mesma
entidade simultaneamente.
Outra característica é o fato de implementar transações por toda a rede distribuída
usando "grupos de entidades". Uma transação manipula entidades dentro de um
único grupo. As entidades do mesmo grupo são armazenadas juntas, para uma
execução de transações eficiente. O aplicativo pode atribuir entidades aos grupos
quando elas forem criadas.
7. SERVIÇOS DO GOOGLE APP ENGINE
O Google App Engine fornece diversos serviços que permitem executar operações
comuns ao gerenciar o aplicativo. As APIs abaixo são fornecidas para acessar estes
serviços:
1.1
Busca de URL:
Aplicativos podem acessar recursos da Internet, como serviços da web ou outros
dados, usando o serviço de busca de URL do Google App Engine. O serviço de
busca de URL recupera recursos da web usando a mesma infraestrutura de alta
velocidade do Google que recupera páginas da web para muitos outros produtos do
Google.
1.2
E-mail:
Aplicativos podem enviar mensagens de e-mail usando o serviço de e-mail do
Google App Engine. O serviço de e-mail usa a infraestrutura do Google para enviar
mensagens de e-mail.
1.3
Memcache:
O serviço de memcache fornece a seu aplicativo um cache de memória essencial de
alto desempenho, que pode ser acessado por diversas instâncias do aplicativo. O
memcache é útil para dados que não precisam dos recursos de persistência e
transações do armazenamento de dados, como dados temporários ou copiados do
armazenamento de dados para o cache para acesso de alta velocidade.
1.4
Manipulação de imagens:
O serviço de imagens permite que o aplicativo manipule imagens. Com esta API,
pode-se redimensionar, cortar, girar e inverter imagens nos formatos JPEG e PNG.
8. TAREFAS AGENDADAS E FILAS DE TAREFAS
Um aplicativo pode desempenhar tarefas além de responder a solicitações da web.
O aplicativo desenvolvido pode realizar essas tarefas seguindo um cronograma
configurado pelo desenvolvedor, por exemplo diariamente ou de hora em hora. O
aplicativo também pode realizar tarefas adicionadas a uma fila pelo próprio
aplicativo, como uma tarefa de segundo plano criada durante o processamento de
uma solicitação.
Tarefas agendadas também são conhecidas como "trabalhos do cron", manipulados
pelo serviço do Cron. Atualmente, filas de tarefas são um recurso lançado em
caráter experimental. No momento, apenas o Python runtime environment pode usar
filas de tarefas. Uma interface de fila de tarefas para aplicativos em Java será
lançada em breve.
9. FLUXO DE DESENVOLVIMENTO
Os SDKs (kits de desenvolvimento de software) do Google App Engine para Java e
Python incluem um aplicativo do servidor da web que emula todos os serviços do
Google App Engine em seu computador local. Cada SDK inclui todas as APIs e
bibliotecas disponíveis no Google App Engine. O servidor da web também simula o
ambiente seguro do sandbox, incluindo verificações de tentativas de acesso não
permitido aos recursos do sistema no runtime environment do Google App Engine.
Cada SDK também inclui uma ferramenta para enviar seu aplicativo para o App
Engine. Depois de criar o código e os arquivos estáticos e de configuração do
aplicativo, executa-se a ferramenta para enviar os dados. A ferramenta solicita o
endereço de e-mail e a senha dea conta do Google do desenvolvedor.
Ao criar uma nova versão principal de um aplicativo já sendo executado no Google
App Engine, pode-se enviá-la como uma nova versão. A versão antiga continuará
servindo os usuários até o desenvolvedor mudar para a nova versão. Pode-se testar
a nova versão no Google App Engine enquanto a versão antiga ainda está sendo
executada.
O SDK para Java é executado em qualquer plataforma com Java 5 ou Java 6. O
SDK está disponível como um arquivo .zip. Se o desenvolvedor utiliza o ambiente de
desenvolvimento Eclipse, pode usar o plug-in do Google App Engine para o
Eclipse para criar, testar e enviar aplicativos do Google App Engine. O SDK inclui
também ferramentas da linha de comando para executar o servidor de
desenvolvimento e fazer upload do aplicativo.
O SDK para Python é implementado em Python puro e executado em qualquer
plataforma com Python 2.5, incluindo Windows, Mac OS X e Linux. O SDK está
disponível como um arquivo zip e há programas de instalação disponíveis para
Windows e Mac OS X.
O Admin Console é a interface baseada na web para gerenciar seus aplicativos
executados no Google App Engine. O desenvolvedor o utiliza para criar novos
aplicativos, configurar nomes de domínio, alterar a versão ativa de seu aplicativo,
examinar registros de acessos e de erros e navegar pelo armazenamento de dados
de um aplicativo.
10. COTAS E LIMITES
Pode-se criar uma conta e publicar um aplicativo que as pessoas usarão
imediatamente sem nenhum custo ou compromisso. Além de poder usar até 500 MB
de armazenamento e até 5 milhões de visualizações de página por mês, o
desenvolvedor pode registrar até 10 aplicativos por conta.
Cada aplicativo recebe recursos dentro de limites chamados "cotas". Uma cota
determina quanto de um determinado recurso o aplicativo pode usar em um dia.
Alguns recursos impõem limites não relacionados a cotas para proteger a
estabilidade do sistema. Por exemplo, quando um aplicativo é chamado para servir
uma solicitação da web, ele deve emitir uma resposta em até 30 segundos. Se o
aplicativo demorar muito, o processo será encerrado e o servidor retornará um
código de erro ao usuário. O tempo de espera de solicitação é dinâmico e pode ser
reduzido para poupar os recursos caso um manipulador de solicitação chegue ao
tempo limite com muita frequência.
11. EXEMPLOS DE USO
1.5
Earth Hour - http://www.earthhour.org/
A Hora do Planeta é um evento mundial organizado pela World Wildlife Fund (WWF)
e realizada no último sábado de março, anualmente, encorajando as famílias e
empresas a desligar seus não essenciais luzes por uma hora para aumentar a
conscientização sobre a necessidade de tomar medidas sobre mudanças
climáticas . O evento, idealizado pela WWF e Leo Burnett , primeira ocorreu em
2007, quando 2,2 milhões de habitantes de Sydney participou por desligar todas as
luzes não essenciais. [ 1 ] Seguindo o exemplo de Sydney, muitas outras cidades ao
redor do mundo adotou o evento em 2008 . A Hora do Planeta 2012 ocorreu em 31
março de 2012 20:30 - 21:30, no tempo dos participantes local.
1.6
A Casa Branca (EUA) Aberto para perguntas http://www.whitehouse.gov/openforquestions
Site (em teste) que propõe aos cidadãos oferecer seus questionamentos para o
governo, envolvendo em principal ponto o próprio Presidente dos EUA. Permite a
interação do mesmo perante as referidas perguntas, e ate mesmo o post de vídeos e
afins.
1.7
Jaiku - http://jaikido.blogspot.com.br/2009/03/jaiku-is-now-served-from-appengine.html
Jaiku foi uma rede social , micro-blogging comparável ao Twitter. Foi fundada em
Fevereiro de 2006 por Engeström Jyri e Petteri Koponen da Finlândia e lançado em
Julho desse mesmo ano. Ela foi comprada pelo Google em 9 de outubro de 2007.
12. BIBLIOGRAFIA
http://pt.wikipedia.org/wiki/Google_App_Engine
https://developers.google.com/appengine/docs/whatisgoogleappengine?hl=pt-br
http://stackoverflow.com/questions/3266783/example-of-large-sites-running-ongoogle-app-engine
http://en.wikipedia.org/wiki/Jaiku
http://en.wikipedia.org/wiki/Earth_Hour
Todos conteúdos acessados em 23 de setembro de 2012.