Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00202 004218 12917215 na godz. na dobę w sumie
Google App Engine. Tworzenie wydajnych aplikacji w Javie - książka
Google App Engine. Tworzenie wydajnych aplikacji w Javie - książka
Autor: Liczba stron: 304
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-4689-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-25%), audiobook).

Od projektu do wdrożenia!

Google App Engine to idealny przykład usługi PaaS (ang. Platform as a Service). W tym modelu płaci się wyłącznie za wykorzystane zasoby dostawcy. Pozwala to na budowanie niezwykle elastycznych rozwiązań informatycznych. Jednak największą zaletą z perspektywy użytkownika tego rozwiązania jest brak konieczności utrzymywania własnej infrastruktury. Niezależnie od sytuacji, będziesz zawsze przygotowany na obsłużenie dowolnie dużego ruchu, a to naprawdę się opłaca!

Dzięki tej książce błyskawicznie rozpoczniesz przygodę z platformą Google App Engine. Autor pokaże Ci, jak szybko tworzyć złożone i wydajne aplikacje w chmurze Google. Zaprezentuje przełomowe techniki, pozwalające na skonstruowanie aplikacji, które są w stanie odpowiedzieć na żądanie w ciągu dwóch sekund przy tzw. zimnym uruchomieniu i w ciągu co najwyżej setek milisekund podczas normalnego działania w pozostałej części sesji. W trakcie lektury dowiesz się, jak uniknąć najczęstszych błędów, które dramatycznie pogarszają wydajność i skalowalność aplikacji w chmurze, oraz poznasz najświeższe technologie do tworzenia interfejsów użytkownika. Proces powstawania aplikacji omówiony został od podstaw - od projektowania i modelowania danych, przez bezpieczeństwo i testowanie, aż po wdrożenie.

Po lekturze tej książki:

Zagwarantuj najlepszą wydajność Twojej aplikacji w każdych warunkach!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Essential App Engine: Building High-Performance Java Apps with Google App Engine Tłumaczenie: Justyna Walkowska ISBN: 978-83-246-4689-0 Authorized translation from the English language edition, entitled: ESSENTIAL APP ENGINE: BUILDING HIGH-PERFORMANCE JAVA APPS WITH GOOGLE APP ENGINE; ISBN 032174263X; by Adriaan De Jonge; published by Pearson Education, Inc, publishing as Addison Wesley. Copyright © 2012 Pearson Education, Inc. All rights reserved. No part of this book may by reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc. Polish language edition published by HELION S.A. Copyright © 2012. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/gooaej.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/gooaej Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Wprowadzenie ............................................................................................................... 13 PodziÚkowania .............................................................................................................. 21 O autorze ....................................................................................................................... 23 I Wprowadzenie do App Engine ......................................................................... 25 1 Konfiguracja Ărodowiska ............................................................................................... 27 Praca z Eclipse .............................................................................................................................. 27 Instalacja wtyczek Eclipse ....................................................................................................... 28 Utworzenie nowego projektu App Engine ............................................................................... 31 Uruchomienie serwera roboczego .......................................................................................... 33 Wdroĝenie aplikacji na serwerach Google .............................................................................. 36 Wdraĝanie z linii poleceñ ............................................................................................................... 39 Uruchamianie serwera roboczego z linii poleceñ ................................................................... 40 Wdraĝanie aplikacji App Engine z linii poleceñ ....................................................................... 40 Podsumowanie .............................................................................................................................. 40 2 WydajnoĂÊ w Ărodowisku App Engine ............................................................................. 41 WydajnoĂÊ w chmurze .................................................................................................................. 41 Porównanie App Engine z tradycyjnymi aplikacjami internetowymi ....................................... 42 Optymalizacja kosztów zasobów ............................................................................................ 42 Pomiar kosztów ïadowania klas .................................................................................................... 42 Czas uruchomienia serwletu zawierajÈcego zewnÚtrznÈ bibliotekÚ ....................................... 43 Czas uruchomienia serwletu niezawierajÈcego zewnÚtrznej biblioteki ................................... 44 Zmniejszenie objÚtoĂci pliku web.xml ..................................................................................... 45 6 Spis treĂci Unikanie zimnych uruchomieñ ...................................................................................................... 47 Rezerwacja stale czynnych instancji ....................................................................................... 47 WstÚpne ïadowanie klas przy uĝyciu ĝÈdañ rozgrzewajÈcych ................................................ 48 Obsïuga wspóïbieĝnych ĝÈdañ w sposób bezpieczny dla wÈtków ............................................ 48 Obsïuga ĝÈdañ wymagajÈcych duĝej iloĂci pamiÚci za pomocÈ instancji typu backend ...... 48 Ogólna poprawa wydajnoĂci ......................................................................................................... 49 Optymalizacja modelu danych pod kÈtem wydajnoĂci .......................................................... 49 Unikanie nadmiarowych obliczeñ przy uĝyciu cache .............................................................. 49 Odraczanie dïugotrwaïych zadañ za pomocÈ kolejki zadañ .................................................. 49 Poprawa szybkoĂci ïadowania stron w przeglÈdarce ............................................................. 50 Asynchroniczne API ................................................................................................................. 50 Optymalizacja aplikacji przed jej wdroĝeniem ........................................................................ 50 Podsumowanie .............................................................................................................................. 51 II Podstawy projektowania aplikacji ................................................................... 53 3 Anatomia aplikacji Google App Engine ........................................................................... 55 Przesyïanie plików w celu wykonania dynamicznego wdroĝenia ................................................. 55 Struktura katalogów ....................................................................................................................... 56 Ustawianie parametrów wdroĝenia ......................................................................................... 58 Uruchamianie zadañ okresowych ........................................................................................... 61 OkreĂlenie indeksów w magazynie danych ............................................................................ 61 Blokowanie zakresów IP .......................................................................................................... 62 Konfiguracja poziomów logowania ......................................................................................... 63 Konfiguracja kolejek zadañ ..................................................................................................... 63 Zabezpieczanie URL ............................................................................................................... 63 Konfiguracja panelu administracyjnego ........................................................................................ 64 Podstawy aplikacji ................................................................................................................... 65 Aktualna wersja ....................................................................................................................... 65 Dodawanie uĝytkowników ....................................................................................................... 66 Naliczanie opïat ....................................................................................................................... 67 Podsumowanie .............................................................................................................................. 67 4 Modelowanie danych na potrzeby magazynu Google App Engine Datastore .................... 69 Odwrót od relacyjnych magazynów danych ................................................................................. 69 Denormalizacja danych ........................................................................................................... 70 Agregacja danych bez zïÈczeñ ............................................................................................... 70 Projektowanie danych bezschematowych .............................................................................. 71 Modelowanie danych .................................................................................................................... 71 Projektowanie na poziomie mikro ........................................................................................... 71 Wybór wïaĂciwoĂci .................................................................................................................. 73 Rozdzielenie encji .................................................................................................................... 73 Spis treĂci 7 Tworzenie i utrzymywanie relacji pomiÚdzy encjami ............................................................... 74 Relacje jeden do wielu i wiele do wielu ................................................................................... 75 Praca z danymi .............................................................................................................................. 76 Transakcje ............................................................................................................................... 76 Zapytania ................................................................................................................................. 77 Tworzenie indeksów ................................................................................................................ 78 Aktualizacja wersji aplikacji korzystajÈcej z Datastore ............................................................ 78 Podsumowanie .............................................................................................................................. 79 5 Projektowanie aplikacji ................................................................................................. 81 Zbieranie wymagañ ....................................................................................................................... 81 Wybór zestawu narzÚdzi ............................................................................................................... 82 Wybór frameworku .................................................................................................................. 82 Wybór systemu szablonów ..................................................................................................... 84 Wybór bibliotek ........................................................................................................................ 85 Decyzje projektowe ....................................................................................................................... 86 Modelowanie danych .............................................................................................................. 86 Modelowanie adresów URL .................................................................................................... 88 Przechodzenie pomiÚdzy stronami ......................................................................................... 89 Podsumowanie .............................................................................................................................. 89 III Podstawy projektowania interfejsu uĝytkownika ............................................. 91 6 Tworzenie interfejsu uĝytkownika w HTML5 ................................................................... 93 Powitajmy HTML5 .......................................................................................................................... 93 Stosowanie nowych znaczników HTML5 ...................................................................................... 94 Rysowanie po pïótnie .................................................................................................................... 96 PrzeciÈganie i upuszczanie na stronach ....................................................................................... 97 Ciekawe elementy formularzy ....................................................................................................... 99 Wykrywanie lokalizacji uĝytkownika ............................................................................................ 100 Przechowywanie danych po stronie klienta ................................................................................ 101 Przechowywanie danych pomiÚdzy sesjami ......................................................................... 102 Przechowywanie danych sesyjnych ...................................................................................... 103 Odpytywanie ustrukturyzowanych danych z wykorzystaniem lokalnej bazy danych SQL ... 104 Podsumowanie ............................................................................................................................ 106 7 Modyfikacja ukïadu strony za pomocÈ CSS .................................................................. 107 Wskazywanie elementów za pomocÈ CSS3 ............................................................................... 107 Obliczanie szczegóïowoĂci ................................................................................................... 108 Identyfikatory ......................................................................................................................... 108 Wskazywanie klas .................................................................................................................. 110 Wskazywanie pseudoklas ..................................................................................................... 110 Wskazywanie atrybutów ........................................................................................................ 111 8 Spis treĂci Wskazywanie elementów ...................................................................................................... 112 Wskazywanie pseudoelementów .......................................................................................... 112 Nowe efekty graficzne CSS3 ....................................................................................................... 113 ZaokrÈglone krawÚdzie ......................................................................................................... 115 Animacje 2D .......................................................................................................................... 116 Animacje 3D .......................................................................................................................... 118 Podsumowanie ............................................................................................................................ 119 8 Statyczna interakcja z wykorzystaniem kodu JavaScript .............................................. 121 Uproszczony przykïad ................................................................................................................. 121 UporzÈdkowanie kodu HTML dziÚki zastosowaniu dyskretnego JavaScriptu ........................... 124 Zmniejszenie zaleĝnoĂci od JavaScriptu poprzez stopniowe rozszerzanie HTML-a .................. 128 Optymalizacja wydajnoĂci za pomocÈ delegacji zdarzeñ .............................................................. 130 Unikanie zmiennych globalnych .................................................................................................. 132 Podsumowanie ............................................................................................................................ 134 9 Dynamiczna interakcja z wykorzystaniem technologii AJAX ......................................... 135 AJAX na sposób klasyczny, bez frameworków ........................................................................... 135 Komunikacja z serwerem za pomocÈ XML-a ........................................................................ 136 Komunikacja z serwerem za pomocÈ formatu JSON ........................................................... 138 Komunikacja z serwerem za pomocÈ HTML-a ..................................................................... 140 Google App Engine Channel API ................................................................................................ 141 Otwarcie kanaïu przez serwer ............................................................................................... 142 Obsïuga komunikatów po stronie klienta .............................................................................. 144 Podsumowanie ............................................................................................................................ 146 IV Korzystanie z popularnych API App Engine ................................................... 147 10 Skïadowanie danych w magazynach Datastore i Blobstore ........................................... 149 Synchroniczne przetwarzanie danych ......................................................................................... 149 Synchroniczne skïadowanie danych ..................................................................................... 150 Synchroniczne odpytywanie danych ..................................................................................... 153 Synchroniczne pobieranie danych ........................................................................................ 154 Asynchroniczne przetwarzanie danych ....................................................................................... 156 Asynchroniczne skïadowanie danych ................................................................................... 156 Asynchroniczne odpytywanie danych ................................................................................... 158 Asynchroniczne pobieranie danych ...................................................................................... 159 Ustanawianie transakcji ............................................................................................................... 160 WieloorganizacyjnoĂÊ i przestrzenie nazw ............................................................................ 162 Skïadowanie i pobieranie duĝych plików .................................................................................... 164 Skïadowanie duĝych plików w Blobstore .............................................................................. 164 Odpytywanie Blobstore ......................................................................................................... 166 Pobieranie plików z Blobstore ............................................................................................... 168 Spis treĂci 9 Wysyïanie duĝej iloĂci danych za pomocÈ Remote API ............................................................. 169 Podsumowanie ............................................................................................................................ 170 11 Wysyïanie i odbieranie poczty elektronicznej ............................................................... 173 Wysyïanie rozbudowanych wiadomoĂci e-mail ze znacznikami HTML i zaïÈcznikami ............... 173 Parametryzacja ciaïa wiadomoĂci ......................................................................................... 176 Zabezpieczenie serwletu ....................................................................................................... 176 Logowanie wysïanych wiadomoĂci na serwerze roboczym ................................................. 177 Alternatywa — JavaMail API .................................................................................................. 177 Porównanie API niskopoziomowego z JavaMail ................................................................... 178 Odbieranie poczty ....................................................................................................................... 179 Konfiguracja serwletu odbierajÈcego pocztÚ ........................................................................ 179 Zapisywanie odebranej poczty przez serwlet ....................................................................... 180 Odbieranie poczty elektronicznej bez JavaMail API .............................................................. 182 BïÚdy ...................................................................................................................................... 184 UwzglÚdnienie wydajnoĂci oraz quoty ........................................................................................ 184 Ile trwa wysïanie wiadomoĂci e-mail? ................................................................................... 184 Jaki jest koszt zimnego uruchomienia? ................................................................................. 185 Czy odbieranie poczty jest wydajne? .................................................................................... 186 Podsumowanie ............................................................................................................................ 186 12 Wykonywanie zadañ w tle za pomocÈ Task Queue API oraz cron .................................. 187 Kolejkowanie zadañ .................................................................................................................... 187 Kolejkowanie wysyïania poczty ............................................................................................. 188 Konfiguracja kolejek .............................................................................................................. 189 Kontrola limitów ..................................................................................................................... 190 Dodatkowe opcje .................................................................................................................. 191 Jak najlepiej wykorzystaÊ kolejki zadañ? .............................................................................. 194 Planowanie zadañ za pomocÈ cron ............................................................................................ 195 Konfiguracja zadañ za pomocÈ cron.xml ............................................................................. 195 Jak najlepiej wykorzystaÊ zadania cron? .............................................................................. 197 Odczyt nagïówków HTTP ............................................................................................................ 197 Podsumowanie ............................................................................................................................ 199 13 Przetwarzanie obrazów z wykorzystaniem usïugi App Engine Image Service ................. 201 OszczÚdne stosowanie Image API ............................................................................................. 201 Odczyt i zapis obrazów ............................................................................................................... 202 Odczyt danych wprowadzonych przez uĝytkownika ............................................................. 202 Zapis w magazynie danych ................................................................................................... 204 Odczyt z magazynu danych .................................................................................................. 205 Zwrócenie obrazu uĝytkownikowi .......................................................................................... 206 Odczyt z pliku ........................................................................................................................ 207 10 Spis treĂci Proste przeksztaïcenia ................................................................................................................ 208 Tworzenie miniatur ................................................................................................................. 208 Przycinanie obrazów .............................................................................................................. 210 Obracanie obrazów ............................................................................................................... 211 Przerzucanie obrazów ........................................................................................................... 211 Zaawansowane przeksztaïcenia ................................................................................................. 211 Podsumowanie ............................................................................................................................ 214 14 Optymalizacja wydajnoĂci za pomocÈ pamiÚci podrÚcznej cache ................................. 215 Podstawowe zastosowanie API memcache ............................................................................... 215 Na co uwaĝaÊ, stosujÈc pamiÚÊ cache? .............................................................................. 215 PamiÚÊ cache i wartoĂci typu String ..................................................................................... 216 Strategia obsïugi cache ............................................................................................................... 218 Redukcja obciÈĝenia App Engine przy uĝyciu nagïówków ETag ......................................... 218 Drobnoziarnista pamiÚÊ cache ................................................................................................... 220 Implementacja interfejsu Serializable .................................................................................... 221 Umieszczanie w cache obiektów w postaci surowej ............................................................ 222 ZarzÈdzanie cache ...................................................................................................................... 222 Uniewaĝnianie elementów w pamiÚci cache ......................................................................... 223 Opróĝnianie cache ................................................................................................................ 224 Inne metody przydatne podczas korzystania z cache ................................................................ 225 Wkïadanie i wyjmowanie wielu wartoĂci ................................................................................ 225 Rejestracja metod obsïugi bïÚdów ........................................................................................ 225 Inkrementacja wartoĂci .......................................................................................................... 225 JSR 107 jako alternatywa dla Memcache Service ...................................................................... 226 Podsumowanie ............................................................................................................................ 226 15 Pobieranie danych z zewnÈtrz za pomocÈ URL Fetch .................................................... 227 Pobieranie danych z URL za pomocÈ ĝÈdañ GET ...................................................................... 227 Wykorzystanie standardowego URL Fetch API ..................................................................... 228 Wykorzystanie niskopoziomowego URL Fetch API ............................................................... 229 Odczyt wyników ........................................................................................................................... 230 Interpretacja wyników ............................................................................................................ 230 Zapis do memcache ............................................................................................................. 230 Zapis do magazynu danych .................................................................................................. 231 Dodatkowe opcje URL Fetch ...................................................................................................... 231 Kontrola czasu wygaĂniÚcia .................................................................................................. 231 Elegancka obsïuga wyjÈtków ................................................................................................ 233 Wysyïanie danych z formularza ................................................................................................... 234 Asynchroniczne pobieranie danych ............................................................................................ 235 Spis treĂci 11 Konsumpcja usïug sieciowych .................................................................................................... 237 Usïugi REST ........................................................................................................................... 237 Komunikacja z SOAP ............................................................................................................ 238 Bezpieczeñstwo .......................................................................................................................... 238 HTTPS .................................................................................................................................... 238 Otwarte porty ......................................................................................................................... 238 Podsumowanie ............................................................................................................................ 239 16 Zabezpieczanie aplikacji internetowych za pomocÈ kont Google, OpenID i OAuth ......... 241 Uwierzytelnianie uĝytkowników w oparciu o konta Google ......................................................... 241 Uwierzytelnianie uĝytkowników za pomocÈ OpenID ................................................................... 244 DostÚp z zewnÈtrz za pomocÈ OAuth ......................................................................................... 246 Zabezpieczanie adresów URL w web.xml .................................................................................. 248 Wymuszenie uwierzytelnienia ................................................................................................ 248 Wymuszenie bezpiecznych protokoïów ................................................................................ 249 Zagadnienia zwiÈzane z bezpieczeñstwem ................................................................................ 249 Walidacja danych wejĂciowych ............................................................................................. 250 Konfiguracja wieloorganizacyjnoĂci ...................................................................................... 250 Przechowywanie danych osobowych ................................................................................... 250 Podsumowanie ............................................................................................................................ 251 17 Wysyïanie i odbieranie wiadomoĂci za pomocÈ XMPP .................................................. 253 Wysyïanie komunikatów XMPP ................................................................................................... 253 Odbieranie komunikatów XMPP .................................................................................................. 255 Odbieranie powiadomieñ o subskrypcji ...................................................................................... 257 Odbieranie powiadomieñ o obecnoĂci ....................................................................................... 260 Podsumowanie ............................................................................................................................ 262 V Wdraĝanie aplikacji ....................................................................................... 263 18 Usprawnienie procesu wytwarzania aplikacji ............................................................... 265 Optymalizacja procesu wytwarzania aplikacji internetowych ..................................................... 265 WejĂcie w skórÚ kierownika projektu ........................................................................................... 266 Mniej prac pobocznych ............................................................................................................... 266 Wyznaczenie ostatecznego celu ........................................................................................... 266 Rezygnacja ze zbÚdnych czynnoĂci ..................................................................................... 267 Rozszerzanie funkcjonalnoĂci ..................................................................................................... 269 OkreĂlenie priorytetów ........................................................................................................... 269 Planowanie iteracji ................................................................................................................. 269 Programowanie sterowane eksperymentem ......................................................................... 270 Stopniowe wprowadzanie zmian ........................................................................................... 271 12 Spis treĂci Mierzenie jakoĂci ......................................................................................................................... 271 Optymalizacja produktywnoĂci programistów ............................................................................ 271 Rytuaïy ................................................................................................................................... 272 Nowe jÚzyki programowania ................................................................................................. 272 ZarzÈdzanie czasem i otoczeniem ........................................................................................ 272 Podsumowanie ............................................................................................................................ 273 19 Zapewnienie jakoĂci za pomocÈ narzÚdzi pomiarowych ................................................ 275 Testowanie w Ărodowisku produkcyjnym .................................................................................... 275 Racjonalna ocena wartoĂci dodanej testów ......................................................................... 276 Testowanie zdroworozsÈdkowe ............................................................................................ 276 Minimalizacja kosztów awarii ................................................................................................ 276 Inne podejĂcie do uĝytecznoĂci .................................................................................................. 277 FunkcjonalnoĂÊ przed wyglÈdem ......................................................................................... 277 Optymalizacja uĝytecznoĂci w oparciu o wyniki profilowania i analizy statystyk .................. 278 Sprawdzanie dostÚpnoĂci za pomocÈ Capabilities API ............................................................. 278 Logowanie nieoczekiwanych zachowañ ..................................................................................... 280 CiÈgïe profilowanie w Ărodowisku produkcyjnym ....................................................................... 282 Badanie reakcji uĝytkownika na Twój interfejs ............................................................................ 285 Podsumowanie ............................................................................................................................ 287 20 Sprzedaĝ aplikacji ....................................................................................................... 289 Jak podejĂÊ do kwestii sprzedaĝy? ............................................................................................. 289 ZnajomoĂÊ odbiorcy ................................................................................................................... 290 Dotarcie do odbiorcy ................................................................................................................... 290 WiadomoĂÊ w serwisie informacyjnym ................................................................................. 290 Pisanie artykuïów ................................................................................................................... 291 Blogowanie ............................................................................................................................ 291 Twitter .................................................................................................................................... 291 Strony na Facebooku ............................................................................................................ 293 Aplikacje na Facebooku ........................................................................................................ 294 Reklamy w Google Apps Marketplace .................................................................................. 295 AdWords ................................................................................................................................ 296 Optymalizacja aplikacji na potrzeby wyszukiwarek ............................................................... 297 Zakïadki spoïecznoĂciowe .................................................................................................... 298 Inne sklepy z aplikacjami mobilnymi ..................................................................................... 298 Zamiana klientów potencjalnych w aktualnych ........................................................................... 299 Obsïuga procesu pïatnoĂci ......................................................................................................... 299 Podsumowanie ............................................................................................................................ 300 Skorowidz .................................................................................................................... 301 3 Anatomia aplikacji Google App Engine W tym rozdziale objaśniam strukturę typowej aplikacji App Engine, przedstawiam sposób or- ganizacji plików przed ich wdrożeniem oraz wskazuję miejsce, w którym pliki są trzymane po wdrożeniu. Początek rozdziału to przegląd serwerów, na których działa aplikacja. W następnej kolejności krótko przedstawiam pliki wchodzące w skład pakietu wdrożeniowego ze szczególnym uwzględnieniem każdego z plików konfiguracyjnych. Rozdział kończy się opisem parametrów konfi- guracyjnych ustawianych w panelu administracyjnym. Przesyïanie plików w celu wykonania dynamicznego wdroĝenia Kiedy wysyłasz aplikację na serwery Google, nie jest ona od razu wdrażana jako działająca instan- cja aplikacji. Zamiast tego aplikacja jest zapisywana na serwerze, z którego może zostać dyna- micznie wdrożona, kiedy zajdzie taka potrzeba. Potrzeba wdrożenia zachodzi wtedy, gdy jeden z serwerów typu frontend odbiera żądanie. W tym kontekście frontend to serwer WWW odbierający żądania przed ich przekazaniem do instancji serwera aplikacji. Na podstawie danych zapisanych w App Masterze frontend podejmuje decyzję, czy żądanie należy przekazać do serwera statycznych plików, czy do jednego z serwerów aplikacji. Serwery uczestniczące w tym procesie zostały przedstawione na rysunku 3.1. serwerach. Wywołanie tych usług zawsze obejmuje pewien narzut komunikacyjny. Google skaluje aplikacje, dynamicznie uruchamiając i zatrzymując serwery aplikacji w zależności od aktualnej listy żądań. Aplikacje reagują nie tylko na ilość obciążenia, ale także na jego pochodzenie. Jeśli na przykład aplikacja zyska popularność w Japonii, Google uruchomi maszyny w (lub nieda- leko od) Japonii. Jeśli większość żądań pochodzi z Niemiec, zostaną uruchomione tamtejsze serwery. Myśląc o wydajności aplikacji App Engine, pamiętaj, że większość usług Google działa na zdalnych 56 Rozdziaï 3. Anatomia aplikacji Google App Engine Rysunek 3.1. PrzeglÈd serwerów i usïug App Engine Na podstawie rysunku 3.1 łatwo zauważyć, że architektura App Engine została oparta o filo- zofię, zgodnie z którą wszystko jest żądaniem HTTP. Wszystkie żądania do instancji App Engine są przesyłane za pośrednictwem HTTP. Simple Mail Transfer Protocol (SMTP), Extensible Messaging and Presence Protocol (XMPP), rozkazy Task Queue i zadania cron — wszystkie te elementy są tłumaczone na żądania HTTP przekie- rowywane przez frontend. Wykorzystanie HTTP ułatwia zarówno obsługę żądań, jak i skalowanie aplikacji App Engine. Skalowanie pod kątem dużej liczby przychodzących wiadomości e-mail przebiega dokładnie tak samo jak skalowanie pod kątem dużej liczby odwiedzin. Struktura katalogów Jeśli Twoja aplikacja ma zostać zainstalowana na serwerach App Engine, musisz jej nadać strukturę przypominającą strukturę archiwum WAR, stosowanego podczas wdrażania na takich serwerach aplikacji jak Tomcat czy Jetty. Pamiętaj jednak, że App Engine nie przyjmuje plików WAR, a poza tym archiwum musi zawierać pewne dodatkowe pliki konfiguracyjne. Zamiast pliku WAR narzędzie wdrożeniowe App Engine oczekuje folderu z rozszerzoną wer- sją pliku WAR. Po kompilacji typowa aplikacja ma strukturę wyglądającą mniej więcej tak: Struktura katalogów 57 /moja-aplikacja/ --/wszelkie-bezpoĂrednio-dostÚpne-pliki --/WEB-INF ----/appengine-generated/ ------/datastore-indexes-auto.xml ----/classes/ (*) ------/najwyĝszy-poziom-twoich-pakietów/ --------/itd./ ----/lib/ (*) ------/wymagany-jar-jeden.jar ------/wymagany-jar-dwa.jar ------/appengine-api-1.5.1.jar ------/appengine-api-labs-1.5.1.jar ----/wszelkie-ukryte-pliki ----/appengine-web.xml (*) ----/cron.xml ----/datastore-indexes.xml ----/dos.xml ----/logging.properties ----/queue.xml ----/web.xml (*) Pliki oznaczone gwiazdką (*) są niezbędne do działania aplikacji. Pogrubienie oznacza, że dany plik w rzeczywistej aplikacji ma dokładnie taką samą nazwę jak na tym listingu. Jeśli nazwa pliku nie została pogrubiona, oznacza to, że została użyta jedynie jako przykład. Uwaga W rzeczywistoĂci katalogi /classes/ i /lib/ nie sÈ konieczne do uruchomienia aplikacji. MógïbyĂ na przykïad stworzyÊ aplikacjÚ internetowÈ zawierajÈcÈ pojedynczy plik JSP niekorzystajÈcy z ĝadnych usïug Google. Jednak w wiÚkszoĂci standardowych aplikacji katalogi te sÈ wymagane. MógïbyĂ takĝe spakowaÊ pliki do wïasnego archiwum JAR i umieĂciÊ je w katalogu /lib/. Istnienie osobnych katalogów /classes/ i /lib/ pozwala jednak na eleganckie rozdzielenie wïaĂciwego kodu programu od zewnÚtrznych bibliotek. Kiedy porównasz listę bibliotek widoczną w zestawieniu z listą standardowo dołączaną przez narzędzia programistyczne Google, może Ci się ona wydać dosyć krótka. Być może zdążyłeś się już przyzwyczaić do tego, że lista zawiera biblioteki Java Data Objects (JDO), Java Persistence API (JPA), DataNucleus, Java Specification Request (JSR) 107 i być może parę innych. Jeśli jednak nie korzystasz z tych bibliotek, nie musisz dołączać ich do aplikacji. W tej książce nie zachęcam do używa- nia tych dodatkowych bibliotek, dlatego nie będą one dołączane do aplikacji. Gdy korzystasz z narzędzi programistycznych Google, takich jak plug-in do Eclipse, pozbycie się wspomnianych bibliotek może być nie lada wyzwaniem. Możesz je skasować, ale one i tak co jakiś czas będą do Ciebie wracały. Trwałym rozwiązaniem tego problemu jest rezygnacja z plug-inu i korzystanie z narzędzi konsolowych. Proste narzędzia konsolowe pozwalają na wykonanie każ- dego zadania realizowalnego z użyciem plug-inu, o ile wiesz, jak skompilować aplikację interne- tową w języku Java. 58 Rozdziaï 3. Anatomia aplikacji Google App Engine Przechodząc na narzędzia konsolowe, uzyskasz większą kontrolę nad tym, jakie pliki będą do- dawane do aplikacji. Jeśli będziesz korzystał z narzędzi konsolowych w sposób pokazany w koń- cowej części rozdziału 1., „Konfiguracja środowiska”, i stworzysz strukturę katalogów analogiczną do tej z ostatniego przykładu, to uzyskasz możliwość wykluczenia z aplikacji każdej biblioteki, której nie potrzebujesz. Prawdopodobnie zechcesz jednak pozostawić w strukturze katalogów bibliotekę appengine- api-x.y.z.jar (gdzie x.y.z to numer aktualnej wersji). Bez niej trudno stworzyć jakąkolwiek uży- teczną aplikację. Tworzenie odpowiednich struktur katalogów mogą Ci ułatwić narzędzia automatyzacji budo- wy, takie jak Maven albo Ant, być może wraz z plug-inem Ivy przeznaczonym dla Ant. Pozwalają one na skompilowanie kodu do żądanej postaci za pomocą polecenia wydawanego z linii komend, niezależnie od tego, jakie środowisko było używane podczas pisania kodu. Budowanie kodu od- bywa się wówczas niezależnie od środowiska programistycznego, co przy okazji ułatwia programi- ście przechodzenie pomiędzy Eclipse, NetBeans i IntelliJ IDEA, kiedy tylko tego zapragnie. Ustawianie parametrów wdroĝenia Za pomocą pliku appengine-web.xml możesz określić parametry konfiguracyjne związane kon- kretnie z Google App Engine. Większość parametrów definiowanych w tym pliku jest opcjonalna. Jeśli ich nie podasz, App Engine użyje wartości domyślnych. Identyfikacja aplikacji Pierwsze dwa elementy, application i version, są obowiązkowe. Google potrzebuje ich do ziden- tyfikowania wdrażanej aplikacji. Przykładowe wartości tych parametrów widać na listingu 3.1. Podczas wdrażania zostaniesz poproszony o podanie adresu e-mail oraz hasła, co pozwoli narzę- dziu wdrożeniowemu na sprawdzenie, czy masz odpowiednie prawa pozwalające na aktualizację danej aplikacji. Kwestia praw zostanie poruszona na końcu tego rozdziału. Listing 3.1 Przykïadowa treĂÊ pliku appengine-web.xml 01 ?xml version= 1.0 encoding= utf-8 ? 02 appengine-web-app xmlns= http://appengine.google.com/ns/1.0 03 application blo-gae /application 04 version 1 /version 05 06 static-files 07 include path= /**.jpg expiration= 6h / 08 exclude path= /resources/**.xml / 09 /static-files 10 11 resource-files 12 include path= /**.xml / 13 exclude path= /static/**.jpg / 14 /resource-files 15 16 !-- Konfiguracja java.util.logging -- Struktura katalogów 59 17 system-properties 18 property name= blog.production-version value= true / 19 property name= java.util.logging.config.file 20 value= WEB-INF/logging.properties / 21 /system-properties 22 23 env-variables 24 env-var name= LANGUAGE value= PL / 25 /env-variables 26 27 ssl-enabled false /ssl-enabled 28 29 sessions-enabled true /sessions-enabled 30 31 user-permissions 32 permission class= com.unknown.CustomPermission 33 name= custom-name actions= read / 34 /user-permissions 35 36 public-root /my /public-root 37 38 inbound-services 39 service mail /service 40 /inbound-services 41 42 precompilation-enabled true /precompilation-enabled 43 44 /appengine-web-app Oddzielenie plików statycznych od zasobów Elementy static-files i resource-files zajmujące linie od 6. do 14. są związane z wysokopo- ziomową strukturą katalogów, omówioną na początku tego rozdziału. Jeśli nie wyspecyfikujesz tych elementów, wszystkie pliki z wyjątkiem tych z /WEB-INF/* zostaną skopiowane zarówno na serwery statycznych plików, jak i na serwery aplikacji. Oznacza to, że zajmą dwa razy więcej miejsca, niż po- winny, przez co możesz szybciej przekroczyć wyznaczony limit darmowego miejsca na dysku (quotę). Katalog /WEB-INF/ i wszystko poniżej jest traktowane jako zasób. Dla każdego innego pliku powinieneś jawnie określić, czy będzie on odczytywany programistycznie po stronie serwera. Jeśli nie, powinieneś usunąć plik z listy zasobów i dodać go do plików statycznych. Zasada ta działa także w drugą stronę. Jeśli któryś z plików poza /WEB-INF/ nigdy nie jest od- czytywany bezpośrednio przez przeglądarkę i służy jedynie jako wejście dla programu działające- go po stronie serwera, rozważ usunięcie go z listy plików statycznych. Może nawet najlepszym rozwiązaniem byłoby przesunięcie takich plików do folderu /WEB-INF/, dzięki czemu zyskasz pewność, że nie zostaną one odczytane nigdzie indziej. Konfiguracja wïaĂciwoĂci systemowych i plików z logami W pliku appengine-web.xml możesz ustawiać właściwości systemowe. Dość ciekawym zastosowa- niem tych właściwości jest określenie, gdzie znajduje się plik logging.properties. Za jego pomocą możesz określić minimalny poziom błędów, o których komunikaty mają trafić do logów. 60 Rozdziaï 3. Anatomia aplikacji Google App Engine Za pomocą zmiennej env-variables określasz zmienne środowiskowe. Nie mają one żadnego dodatkowego zastosowania w App Engine. Zmienne środowiskowe można pobrać wewnątrz pro- gramu, wywołując metodę System.getProperty(). Sesje Domyślnie aplikacje Google App Engine są całkowicie bezstanowe i nie wspierają sesji. Jeśli jed- nak przełączysz element sessions-enabled na true, będziesz mógł korzystać z klasy HttpSession z interfejsu Servlet. Decydując się na wykorzystanie sesji, miej na uwadze, że ich implementacja korzysta zarówno z magazynu Datastore, jak i z memcache. Ceną jest ilość miejsca na dysku, a potencjalnie także gorsza wydajność związana z odczytem i zapisem danych w cache. Oznacza to, że musisz rozważyć zarówno koszty komunikacji z zewnętrznymi usługami, jak i koszty serializacji obiektów. Wszystkie obiekty dodawane do sesji powinny implementować java.lang.Serializable. Garść ostrzeżeń dotyczących stosowania tego interfejsu znajdziesz w roz- dziale 14., „Optymalizacja wydajności za pomocą pamięci podręcznej cache”. Bezpieczeñstwo aplikacji W chwili pisania tego tekstu Google App Engine wspiera połączenia Secure Sockets Layer (SSL) tylko dla aplikacji działających w domyślnej domenie appspot. Jeśli aplikacja jest uruchomiona we własnej domenie użytkownika, wykorzystanie SSL nie jest (na razie) możliwe. Trwają prace nad implementacją tego wymagania. Aktualny stan i plany rozwoju App Engine możesz podejrzeć tu- taj: http://code.google.com/intl/pl/appengine/docs/roadmap.html. W tej chwili, zakładając, że Twoja aplikacja działa w domenie appspot, możesz zażądać zabez- pieczenia URL za pomocą HTTPS, korzystając z elementu ssl-enabled. Decyzja dotyczy wszyst- kich adresów URL: albo wszystkie są zabezpieczone, albo żaden. Nie ma możliwości wskazania podgrupy, która ma zostać zabezpieczona. Na potrzeby bibliotek języka Java dostarczających zewnętrzne klasy uprawnień możesz skonfi- gurować uprawnienia za pomocą elementu user-permissions. W przypadku niektórych frame- worków jego zastosowanie może być obowiązkowe, jednak w przykładach w tej książce nie bę- dziemy z niego korzystać. Poza możliwością dodawania i usuwania plików z serwera plików statycznych możesz użyć jeszcze jednego elementu — public-root — w celu uniemożliwienia dostępu do plików statycz- nych. Skorzystanie z tego elementu nie powoduje zmiany lokalizacji plików statycznych ani od- powiadających im adresów URL. Oznacza on tyle, że nie można odwołać się do żadnego katalogu na serwerze plików statycznych poza tym wskazanym jako public-root. Jeśli jako public-root wska- żemy /static, nie będziemy mieli dostępu do plików na ścieżce /inne. Dostępne będą natomiast pliki zagnieżdżone głębiej we wskazanym katalogu, na przykład /static/podpoziom/jeszcze-inne. Struktura katalogów 61 Konfiguracja usïug Rysunek 3.1 przedstawia cztery usługi mające dostęp do frontendu w celu wywoływania akcji na serwerach aplikacji: Task Queue, cron, Mail i XMPP. Jedynie Mail i XMPP trzeba jawnie zadekla- rować jako włączone w pliku appengine-web.xml. Różnica pomiędzy XMPP i Mail a resztą jest taka, że są one usługami przyjmującymi, które odpowiadają na przychodzące z zewnątrz żądania korzystające z protokołów innych niż HTTP. Możesz je włączyć, przypisując wartości mail lub xmpp_message elementowi inbound-services, jak w przykładzie z listingu 3.1 (linia 39.). WyïÈczenie prekompilacji Z powodów optymalizacyjnych Google App Engine prekompiluje bajtkod przed uruchomieniem aplikacji. W wiÚkszoĂci przypadków operacja ta nie jest zauwaĝalna. Istnieje jednak co najmniej jeden scenariusz, w którym warto rozwaĝyÊ jej wyïÈczenie: jeĂli musisz korzystaÊ z podpisanych bibliotek JAR, prekompilacja zepsuje podpis. W takiej sytuacji ustaw wartoĂÊ elementu precom- pilation-enabled na false. Uruchamianie zadañ okresowych Możesz wykorzystać plik cron.xml do planowania wykonania zadań. Usługa cron uruchamia za- dania, wysyłając żądania HTTP do serwerów frontend. Przykładowa treść pliku konfiguracyjnego cron.xml została przedstawiona na listingu 3.2. Więcej informacji na temat tej usługi i jej konfiguracji znajdziesz w rozdziale 12., „Wykonywanie zadań w tle za pomocą Task Queue API oraz cron”. Listing 3.2. Przykïadowa zawartoĂÊ pliku cron.xml 01 ?xml version= 1.0 encoding= UTF-8 ? 02 cronentries 03 cron 04 url /tasks/cron/mail /url 05 description WyĂlij spamerski e-mail… /description 06 schedule every 2 minutes /schedule 07 /cron 08 cron 09 url /tasks/cron/read-rss /url 10 description Odczytaj strumieñ RSS… /description 11 schedule every day 22:00 /schedule 12 timezone Africa/Johannesburg /timezone 13 /cron 14 /cronentries OkreĂlenie indeksów w magazynie danych W strukturze plików na początku rozdziału zauważysz dwa pliki, których nazwy zaczynają się od datastore-indexes: są to pliki datastore-indexes.xml oraz datastore-indexes-auto.xml. Plik datastore-indexes.xml służy do wskazania, które właściwości których encji powinny zostać zindeksowane w celu optymalizacji czasu zapytań do magazynu danych. 62 Rozdziaï 3. Anatomia aplikacji Google App Engine Plik datastore-indexes-auto.xml w katalogu /WEB-INF/appengine-generated jest tworzony przez serwer roboczy. Może on współpracować z datastore-indexes.xml, o ile wartość atrybutu autoGenerate jest ustawiona na true. W przeciwnym razie jest używany jedynie plik datastore-indexes.xml, a datastore-indexes-auto.xml jest ignorowany. Listing 3.3 przedstawia treść pliku datastore-indexes.xml, który pozwala serwerowi roboczemu na automatyczne wprowadzanie zmian w pliku datastore- indexes-auto.xml. Listing 3.3. Przykïadowa zawartoĂÊ pliku datastore-indexes.xml 01 ?xml version= 1.0 encoding= utf-8 ? 02 datastore-indexes 03 autoGenerate= true 04 datastore-index kind= BlogPost ancestor= false 05 property name= title direction= asc / 06 property name= entry-date direction= desc / 07 /datastore-index 08 09 datastore-index kind= User ancestor= false 10 property name= name direction= asc / 11 /datastore-index 12 /datastore-indexes Więcej informacji na temat tworzenia indeksów i korzystania z nich znajdziesz w rozdziale 4., „Modelowanie danych na potrzeby magazynu Google App Engine Datastore”. Blokowanie zakresów IP W celu ochrony aplikacji przed nadużyciami możesz chcieć ograniczyć dostęp do niej za pomocą zakresu adresów IP. Możesz wpisać adres IP lub zakres adresów na „czarną listę” przy użyciu pliku dos.xml (nazwa to skrót od denial of service — odmowa obsługi). Listing 3.4 przedstawia przykład zablokowania jednego konkretnego adresu IP z zakresu IPv4 oraz jednej podsieci. Podsieć została zdefiniowana za pomocą notacji Classless Inter-Domain Ro- uting (CIDR). Pełne objaśnienie CIDR wykracza poza zakres tej książki, jednak z łatwością znaj- dziesz w internecie zasoby opisujące ten koncept. Listing 3.4. Przykïadowa treĂÊ pliku dos.xml 01 ?xml version= 1.0 encoding= UTF-8 ? 02 blacklistentries 03 blacklist 04 subnet 170.224.225.27 /subnet 05 description Jeden konkretny adres /description 06 /blacklist 07 blacklist 08 subnet 170.224.225.0/24 /subnet 09 description Caïa podsieÊ /description 10 /blacklist 11 /blacklistentries Struktura katalogów 63 Konfiguracja poziomów logowania Listing 3.1 zawiera odwołanie do pliku logging.properties. Za pomocą tego pliku możesz określić poziom logowania, wskazując najmniej ważny poziom komunikatów, które mają już zostać uwzględ- nione w plikach z logami. Przykład z listingu 3.5 definiuje logowanie wszystkich komunikatów o poziomie co najmniej INFO, niezależnie od pakietu czy klasy. Listing 3.5. Definicja poziomu logowania w pliku logging.properties 01 #logging.properties 02 # Ustaw domyĂlny poziom logowania dla wszystkich loggerów na INFO 03 .level = INFO Inne poziomy to trace, debug, warning, error i fatal. Możesz wprowadzić różne ustawienia dla różnych części aplikacji, wskazując nazwy pakietów lub pełne nazwy klas przed ciągiem .level. Jest to standardowy mechanizm konfiguracji java.util.logging. Konfiguracja kolejek zadañ Jeśli nie stworzysz pliku queues.xml, będzie istniała jedna domyślna kolejka zadań o przepustowości pięciu zadań na sekundę. Jeśli chcesz wprowadzić dodatkowe kolejki o różnej przepustowości, możesz dodać plik queues.xml, taki jak na listingu 3.6. Więcej informacji na ten temat znajdziesz w rozdziale 12., „Wykonywanie zadań w tle za pomocą Task Queue API oraz cron”. Listing 3.6. Przykïadowa treĂÊ pliku queues.xml 01 ?xml version= 1.0 encoding= utf-8 ? 02 queue-entries 03 queue 04 name mail-queue /name 05 rate 2000/d /rate 06 /queue 07 queue 08 name second-mail-queue /name 09 rate 8/m /rate 10 /queue 11 /queue-entries Zabezpieczanie URL Większość plików konfiguracyjnych, które się pojawiły w tym rozdziale, była związana ze specyfi- ką App Engine i nie miałaby sensu przy wdrożeniu aplikacji w innym kontenerze. Jednak istnieje część konfiguracji, która działa tak samo we wszystkich standardowych kontenerach serwletów. Chodzi tu o jedyny pominięty do tej pory plik konfiguracyjny — web.xml. Nie wymaga on zbyt obszernych wyjaśnień. 64 Rozdziaï 3. Anatomia aplikacji Google App Engine Warto jednak wspomnieć przynajmniej jedną z części tego pliku — ograniczanie dostępu do poszczególnych adresów URL, tak by tylko zalogowani użytkownicy mogli się do nich odwołać. Fragment pliku web.xml opisujący adres URL o ograniczonym dostępie przedstawia listing 3.7. Listing 3.7. Fragment pliku web.xml 01 ?xml version= 1.0 encoding= utf-8 ? 02 web-app xmlns:xsi= http://www.w3.org/2001/XMLSchema-instance 03 xmlns= http://java.sun.com/xml/ns/javaee 04 xmlns:web= http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd 05 xsi:schemaLocation= http://java.sun.com/xml/ns/javaee 06 http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd 07 version= 2.5 08 09 !-- […] -- 10 11 servlet 12 servlet-name ReceiveMailServlet /servlet-name 13 servlet-class com.appspot.mail.[…] /servlet-class 14 /servlet 15 servlet-mapping 16 servlet-name ReceiveMailServlet /servlet-name 17 url-pattern /_ah/mail/* /url-pattern 18 /servlet-mapping 19 20 !-- […] -- 21 22 security-constraint 23 web-resource-collection 24 web-resource-name receive-mail-url /web-resource-name 25 url-pattern /_ah/mail/* /url-pattern 26 /web-resource-collection 27 auth-constraint 28 role-name admin /role-name 29 /auth-constraint 30 /security-constraint 31 32 !-- […] -- 33 34 /web-app W linii 28. pojawia się nazwa roli admin. Możliwe są tutaj tylko dwie wartości: * lub admin. Wartość admin oznacza, że tylko zarejestrowani programiści aplikacji lub systemu mogą uzyskać dostęp do danego URL. Z kolei wartość * wskazuje, że dostęp może uzyskać każdy zalogowany użytkownik. Konfiguracja panelu administracyjnego Większość ustawień konfiguracyjnych Google App Engine definiuje się w plikach konfiguracyj- nych dostarczanych wraz z aplikacją. Jednak pewna niewielka część konfiguracji odbywa się za pośrednictwem panelu administracyjnego. W przypadku większości obecnych tam opcji oczywiste Konfiguracja panelu administracyjnego 65 jest, dlaczego nie trafiły one do plików konfiguracyjnych. Bez wdawania się w filozoficzne dysputy można stwierdzić, że powody są czysto praktyczne. Panel administracyjny jest dość zwięzły i ła- two się w nim odnaleźć. Podstawy aplikacji Na ekranie Application Settings (ustawienia aplikacji) możesz ustawić kilka podstawowych para- metrów, takich jak nazwa aplikacji, czas ważności ciasteczek oraz sposób uwierzytelniania użyt- kowników. Możesz podać własną nazwę domenową, a także dezaktywować lub skasować aplika- cję, jeśli nie chcesz już świadczyć usług. Ten ekran panelu administracyjnego został przedstawiony na rysunku 3.2. Rysunek 3.2. OkreĂlenie nazwy aplikacji, dziedziny oraz mechanizmu uwierzytelniania Aktualna wersja Listing 3.1 zawierał informację na temat wersji. Za pomocą panelu administracyjnego widocznego na rysunku 3.3 możesz przełączyć wersję aplikacji. Umożliwia to przygotowanie się do aktualizacji i podjęcie decyzji, kiedy nowa wersja stanie się aktywna. Możliwe jest także wycofanie wersji w przy- padku nieoczekiwanych problemów. Pamiętaj, że niezależnie od wersji aplikacji uruchomiona jest tylko jedna wersja magazynu danych. Dostęp do danych należy implementować, mając na uwadze kompatybilność wstecz i w przód. 66 Rozdziaï 3. Anatomia aplikacji Google App Engine Rysunek 3.3. Wybór wersji aplikacji Dodawanie uĝytkowników W miarę zdobywania popularności przez aplikację możesz chcieć dodawać do niej zaufane osoby, które będą sprawowały kontrolę nad sytuacją w czasie, gdy jesteś niedostępny. Możesz nadawać innym osobom prawa w oparciu o konta Google. Tacy użytkownicy mogą zarządzać aplikacjami i dodawać nowe wersje. Ekran dodawania użytkownika został przedstawiony na rysunku 3.4. Rysunek 3.4. Zapraszanie dodatkowych uĝytkowników do sprawowania kontroli nad systemem Podsumowanie 67 Naliczanie opïat Gdy aplikacja stanie się popularna, może się okazać, że wyczerpałeś limit darmowych zasobów Google. Jeśli aplikacji towarzyszy przemyślany model biznesowy, nie powinno to stanowić pro- blemu. Możesz wybrać, jaką ilość i które z dostępnych zasobów chcesz opłacać. Rysunek 3.5 przedsta- wia ustawienia związane z płatnościami. Rysunek 3.5. Konfiguracja pïatnoĂci za zasoby przekraczajÈce dzienny darmowy limit Podsumowanie Po przeczytaniu tego rozdziału powinieneś mieć całkiem niezłe pojęcie na temat konfiguracji aplikacji App Engine. Na początku rozdziału przedstawiłem ogólną
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Google App Engine. Tworzenie wydajnych aplikacji w Javie
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: