Google App Engine (2)

TALLINNA ÜLIKOOL Matemaatika -loodusteaduskond Informaatika instituut
Google App Engine Iseseisev töö aines Veebiprogrammeerimine IFI6011
Andris Reinman ITJ-08 Õppejõud: Jaagup Kippar
Tallinn 2010 Google App Engine ­ Andris Reinman
Sisukord Google App Engine............................................................................................................................ 1 Sisukord......................................................................................................................................... 2 Tutvustus....................................................................................................................................... 4 Kasutamine........................................................................................................................................ 6 Platvorm ......................................................................................................................................... 6 Paigaldus....................................................................................................................................... 7 SDK käsud..................................................................................................................................... 8 Uue aplikatsiooniprojekti loomine.................................................................................................. 9 Aplikatsiooni registreerimine appspot.com teenuses.................................................................. 10 app.yaml kasutamine................................................................................................................... 11 Ülesehitus................................................................................................................................ 11 HTTP vs. HTTPS.................................................................................................................... 13 Kohustuslik sisselogimine ....................................................................................................... 13 Perioodilised tööd........................................................................................................................ 14 Programmeermiskeel Python ........................................................................................................... 14 Tutvustus..................................................................................................................................... 14 Programmi struktuur.................................................................................................................... 15 Abiteekide laadimine .................................................................................................................... 17 Keele struktuurid .......................................................................................................................... 17 Muutujad ja andmetüübid........................................................................................................ 17 Tekst................................................................................................................................... 18 Numbrid.............................................................................................................................. 18 Massiivid ............................................................................................................................. 18 Assotsiatiivsed massiivid.................................................................................................... 18 Tsüklid..................................................................................................................................... 19 FOR tsükkel........................................................................................................................ 19 WHILE tsükkel.................................................................................................................... 19 Tingimuslause IF..................................................................................................................... 19 Funktsioonide defineerimine ................................................................................................... 20 Veahaldus ............................................................................................................................... 20 Klassid..................................................................................................................................... 20 Veebispetsiifilised elemendid....................................................................................................... 21 GET ja POST parameetrid ...................................................................................................... 21 Küpsised................................................................................................................................. 21 Vastusepäise seadmine .......................................................................................................... 21 Django lehemallid............................................................................................................................. 23 Tutvustus..................................................................................................................................... 23 Muutujad...................................................................................................................................... 23 Filtrid............................................................................................................................................ 24 Tingimuslaused ............................................................................................................................ 24 Tsüklid.......................................................................................................................................... 25 Lehemallide pärilikkus................................................................................................................. 25 Lehemalli kasutamise näide........................................................................................................ 26 BigTable andmebaas ........................................................................................................................ 28 Tutvustus..................................................................................................................................... 28 Kasutamine.................................................................................................................................. 29 Tabelite defineerimine............................................................................................................. 29 Andmete lisamine.................................................................................................................... 29 Andmete pärimine................................................................................................................... 30 Andmete kustutamine............................................................................................................. 30 Andmetüübid................................................................................................................................ 30 Property klass......................................................................................................................... 30 Property tüübid........................................................................................................................ 31 Andmete päring baasist............................................................................................................... 32 Päringuliides............................................................................................................................ 33 GQL......................................................................................................................................... 33 Indeksid....................................................................................................................................... 34 Transaktsioonid ............................................................................................................................ 35
2 / 55 Google App Engine ­ Andris Reinman
GAE spetsiifilised teegid................................................................................................................... 35 Google kasutajad......................................................................................................................... 35 Memcache................................................................................................................................... 37 E-post.......................................................................................................................................... 38 Kirjade saatmine ..................................................................................................................... 38 Kirjade vastuvõtmine............................................................................................................... 38 Veebiaadresside laadimine.......................................................................................................... 40 Piltide redigeerimine .................................................................................................................... 41 Pildi laadimine.................................................................................................................... 41 Suuruse muutmine............................................................................................................. 41 Pööramine.......................................................................................................................... 41 Ümberpööramine................................................................................................................ 41 Lõikamine........................................................................................................................... 41 Värvuste sättimine.............................................................................................................. 42 Pildi väljastamine................................................................................................................ 42 Tegumid....................................................................................................................................... 42 Tegumi väljakutsumine....................................................................................................... 42 Tegumi deklareerimine ....................................................................................................... 43 Täiendavad võimalused................................................................................................................... 44 Tasulised võimalused................................................................................................................... 44 Oma domeeni kasutamine........................................................................................................... 45 Palja domeeni probleem..................................................................................................... 45 HTTPS probleem................................................................................................................ 45 Suvalised alamdomeenid................................................................................................... 45 Lisad................................................................................................................................................. 46 Lisa 1. Hello World rakenduse ülesseadmine.............................................................................. 46 Rakenduse registreerimine..................................................................................................... 46 Rakenduse loomine................................................................................................................ 48 Rakenduse ülesseadmine....................................................................................................... 49 Lisa 2. Näidisrakendus................................................................................................................ 51 Failide sisu.............................................................................................................................. 52 app.yaml............................................................................................................................. 52 index.yaml.......................................................................................................................... 52 main.py............................................................................................................................... 52 index.html........................................................................................................................... 54 leht.css............................................................................................................................... 55 Näidisrakenduse demo........................................................................................................... 55
3 / 55 Google App Engine ­ Andris Reinman
Tutvustus Google App Engine on Google infrastruktuuril põhinev veebiaplikatsioonide platvorm. Tegu on pilveteenusega, kus andmed asuvad serverite ,,pilves," võimaldades vajaduste saabudes kasutada aina rohkem ja rohkem ressursse. Sellise infrastruktuuriga teenused on väga suures ulatuses skaleeruvad, kuna kui ressursse puudu jääb, saab neid ,,lennult" juurde haarata. Tavalise serveri puhul saab ressursse kasutada vaid konkreetse serveri limiitide raames ning kui nendest ei jätku, tuleb kas serveri riistvara uuendada või server üldse välja vahetada. Teenuse hinnastamine käib pilveteenuste juures põhimõttel, et maksad vaid selle eest, mida kasutad ning kuni esimesete limiitide ületamiseni (limiidid on peamiselt päevapõhised) on Google App Engine teenus üldse tasuta. Kui teenuse koormus ja ressursikasutus tõuseb, siis maksad rohkem, aga kui langeb, siis pead ka jälle vähem maksma. Kuna Google App Engine limiidid on välja töötatud USA turu järgi, siis on Eesti veebisaitide puhul, kus koormused on rahvastiku arvust tulenevalt niigi väikesed, ,,raske" isegi tasuta limiitidest üle saada. Päris kaua, kui mitte jäädavalt saab aplikatsiooni kasutada ilma et tekiks vajadust Googlele sentigi maksta - nii võibki pidada Eesti oludes Google App Engine't tingimuslikult üldse tasuta teenuseks. Google App Engine pakubki esmaselt valida kasutamiseks täiesti tasuta paketi , mille peamiseks erinevuseks tasulisest paketist on fakt, et limiitide ületamise korral jääb aplikatsioon kuni limiitide vabanemiseni (uue päeva alguseni ) seisma, samas kui tasulise versiooni puhul esitatakse üle tasuta limiitide läinud ressursside eest lihtsalt arve. Eriti hästi sobivad Google App Engine laadsed teenused automaatse skaleeruvuse tõttu sellistele aplikatsioonidele, kus on suuri ressursse vaja ainult vahel harva, ülejäänud ajal aga on teenuse kasutamine väike kui mitte olematu. Nii ei ole vaja nende harvade tavalisest suurema koormusega hetkede tarbeks ennetavalt osta ja hallata kallimat riistvara ja võrguühendust, mis niikuinii enamusest ajast istuks lihtsalt jõude, kuna tavaolukorras serveril vastav koormus puudub. Heaks näiteks skaleeruva ressursikasutuse vajalikkuse kohta, oleks niiöelda digg ning slashdot efektid . See tähendab, et veebilehe viide satub mõne populaarse linkija esilehele , olgu selleks siis Digg.com, Slashdot.com vms - tagajärjeks on aga, et väga piiratud ajaperioodi jooksul (mõned tunnid kuni mõned päevad, niikaua kui link püsib taolise linkija esilehel), külastab teenust väga palju kasutajaid. Klassikalise veebimajutuse korral kukuks server ülekoormuse all kokku, aga skaleeruva teenuse puhul tuleks kuu lõpus lihtsalt harjumuspärasest veidi suurem arve, teenus aga jääks endiselt toimima . Tasuta paketi peamised limiidid on ära toodud allolevas tabelis. Juhul kui tasuta paketi korral need limiidid ületatakse peatub aplikatsiooni teenindamine Google serverite poolt ning kasutajad näevad lehe avades Google logoga veateadet.
Resurss Päevane limiit Maksimaalne sagedus Pöördumisi 1 300 000 päringut 7 400 päringut minutis Väljuv andmemaht 1 GB 56 MB minutis Sisenev andmemaht 1 GB 56 MB minutis Protsessorikasutus 6.5 CPU tundi 15 CPU minutit minutis Kasutatav kettapind 1 GB E-posti saatmine 2000 väljuvat kirja 8 kirja minutis Memcache päringuid 8 600 000 48 000 päringut minutis Tabel 1. Tasuta kasutamise limiidid Google App Engine aplikatsioonide jaoks
4 / 55 Google App Engine ­ Andris Reinman
Tasulise paketi korral jäävad tasuta limiidid samaks ning maksta tuleb ainult nende ressursside eest, mis lähevad tasuta limiitidest üle. Muutuvad aga maksimaalsed sagedused, mis tõusevad tasulise paketi korral päris suures ulatuses. Näiteks kui väljuv andmemaht on tasuta paketis maksimaalse sagedusega 56 MB/minutis, siis tasulises paketis on sama numbri asemel väärtus 10 GB/minutis, e-kirjade saatmise limiit tõuseb tasuta paketi 8 kirjalt minutis 5100 kirjani minutis. Samas kui väljuv andmemaht, kirjade saatmine vms. jääb ikkagi tasuta piiride sisse (väljuva andmemahu puhul alla 1 GB päevas), siis tasulise paketiga kaasnenud täiendava sageduse tõusu eest juurde maksma ei pea ning see tuleb nn. ,,tasuta kätte."
5 / 55 Google App Engine ­ Andris Reinman
Kasutamine
Platvorm Google App Engine erineb teistest pilveteenuste pakkujatest (näiteks Amazon AWS teenused) selle poolest, et pakub mitte üldist laadi majutust, vaid kindlaksmääratud platvormil aplikatsioonide majutust. Kogu arveldamine käibki aplikatsioonide järgi - igal aplikatsioonil on kasutada teatud arv ressursse ning ka maksta tuleb vastavalt konkreetse aplikatsiooni ressursikasutuse järgi, mitte kuidagi üldisemalt, näiteks aplikatsiooni omaniku poolt ressursside üldkasutuse järgi. Seega päris suvalisi faile Google App Engine serverites hoida ei saa ning kinni tuleb pidada mitmetest reeglitest ja tuleb arvestada erinevate piirangutega. Esiteks programmeerimiskeele valik - valida on ainult kahe keskkonna vahel, Java ning Python. Käesolev juhend ongi kirjutatud Pythoni põhise keskkonna nõudmiste järgi. Kolmandate keelte (näiteks PHP või Ruby ) kasutamine on reeglina võimalik vaid Java abil, kui eksisteerib Java interpretaator vastava keele jaoks. See tähendab, et võetakse näiteks PHP keeles kirjutatud skript , tõlgitakse see Java'le loetavaks ning Java käivitab selle Google App Engine platvormil tavalise Java põhise aplikatsioonina. Teiseks oluliseks erinevuseks muude teenusepakkujatega, on andmebaasivalik. Google App Engine ei toeta MySQL , MSSQL ega muid relatsioonilist andmebaase, vaid kasutusel on Google poolt välja töötatud mitte- relatsiooniline BigTable andmebaas . BigTable suurimaks piiranguks on kuni 1 MB suurused andmebaasi kirjed . Üldiselt ei tohiks selline piirang probleemiks olla, aga kuna GAE ei võimalda aplikatsioonidele failisüsteemi kirjutamise õigust ning kõik programmi töö jooksul lisatud failid tuleb salvestada failisüsteemi asemel andmebaasis , võib 1 MB piirang suht probleemseks osutuda. Õnneks on alternatiivina võimalik kasutada suuremate failide salvestamiseks BlobStore failihoidlat, kuid selle kasutamine on mõnevõrra keerukam ning nendele failidele ei pääse programmiliselt ligi (ei saa lugeda faili sisu jms.). Kolmandaks suureks piiranguks on eelpoolnimetatud 1 MB piirang. Andmebaasi iga kirje ning kirjes iga objekt eraldi peab jääma 1 MB raamidesse, teistest serveritest saab tõmmata ainult kuni 1 MB suuruseid faile, välja saadetava e-kirja maksimaalne suurus koos manustega saab olla 1 MB jne. Nagu ka öeldud, saab osadel juhtudel (suurte failide salvestamiseks) kasutada selle jaoks spetsiaalselt välja töötatud BlobStore teenust, kuid ka sellel on omad piirangud. Neljandaks server ise - Google App Engine ei võimalda serverile harjumuspärast ligipääsu mõne failiedastusprotokolli abil nagu näiteks FTP. Failide laadimine on ainult ühesuunaline - faile saab laadida ainult üles. Kui staatilisi faile saab veebi kaudu tava-korras siiski ka alla laadida, siis programmifaile serverist enam tagasi alla laadida ei saa - kui aplikatsiooni lähtefaile enam kohalikus arvutis alles pole, siis neid kuskilt ka enam taastada ei saa. Sellisel juhul aga pole võimalik ka serveris enam muudatusi teha, kuna korraga uuendatakse ära terve aplikatsioon, mitte ei saa toimetada ainult ühe faili kallal. Taolise probleemi vältimiseks tasub kindlasti kaaluda täiendavalt mõne versioonihalduskeskkonna kasutamist, näiteks SVN vms, kuhu lähtefailid turvaliselt ära salvestada saaks. Kui aga kirjeldatud piirangud loodavat programmi ei ahista - programm on kirjutatud programmeerimiskeeles Python, kasutab andmebaasina BigTable baasi, kõik objektid jäävad 1MB
6 / 55 Google App Engine ­ Andris Reinman
piiresse ning lähtefailid on turvaliselt varundatud, siis on Google App Engine aplikatsiooni loomiseks tõenäoliselt parim valik.
Paigaldus Google App Engine kasutamiseks on vaja paigaldada arvutisse vastav tarkvara arenduspakett (SDK), mille saab alla laadida Google App Engine kodulehelt [ http://code.google.com/intl/et/appengine/downloads.html ]. Valida on kolme versiooni vahel, millest igaüks on mõeldud eri platvormi jaoks. Alla saab laadida Windowsi versiooni, Mac'i versiooni või Linuxi versiooni. Kõik need teevad sisuliselt sama asja, koosnedes samadest pyhtoni skriptidest, ainult et Windowsi ning Mac'i versioonide puhul on skriptide juurde lisatud ka graafiline liides nende skriptide käivitamiseks. Linuxi puhul peab ,,käsitsi" hakkama saama. Arenduspaketti on tarvis peamiselt kahel põhjusel. Esiteks sisaldab see endas kohaliku veebiserveri näol virtuaalset Google App Enginet ennast - ehk et saab kohe arendusarvutis, ilma üles laadimata proovida kuidas programm töötab või mitte - ning teiseks käib kogu failide üleslaadimine Google serveritesse justnimelt läbi arenduskeskkonna vastava liidese. Harjumuspäraseid FTP/SSH vms. failiedastusvahendeid seega Google App Engine jaoks programme luues kasutada ei saa, kogu vajalik funktsionaalsus on realiseeritud SDK enda sees. SDK poolt kontrollitav üleslaadimine on samas väga mugav, piisab ainult ühest nupuvajutusest ,,Deploy" nupul või Linuxi puhul (kuna graafiline keskkond puudub) üleslaadimise käsu sisestamisest. SDK laeb üles ainult failid, mis on uued või mida on muudetud, teisi faile ei puututa. Samuti toimib taustal paigalduste versioonimine - juhul kui üleslaadimine ebaõnnestus või programm osutus vigaseks, saab üleslaadimist ,,tagasi pöörata," misjärel taastab server programmi eelmise oleku. Kuna olemasolevaid faile ei kirjutata kunagi üle, vaid ainult lisatakse juurde, ei saa tekkida ka probleemi, kus programm on serveris lootusetult katki läinud - alati saab naasta eelmise versiooni juurde.
7 / 55 Google App Engine ­ Andris Reinman
Joonis 1. Google App Engine SDK graafiline liides programmide haldamiseks Windows ja Mac keskkondades sisaldab SDK graafilist töökeskkonda, mis võimaldab mugavalt luua uusi aplikatsiooniprojekte, neid serverisse laadida ning lokaalses veebiserveris testida. Linux keskkonnas graafiline liides (hetkel) puudub, selle asemel tuleb kasutada tekstilisi käsklusi.
SDK käsud
Run - Aplikatsiooni käivitamine GAE emulaatoris (lokaalne veebiserver ) Linuxis asendab käsklus dev_appserver.py aplikatsiooni_kaust
Stop - Lokaalse veebiserveri töö lõpetamine Linuxis tuleb sulgeda programm dev_appserver.py (klahvikombinatsioon ctrl +z)
8 / 55 Google App Engine ­ Andris Reinman
Browse - Veebilehitseja avamine aplikatsiooni aadressiga lokaalses veebiserveris Linuxis tuleb avada veebilehitseja aadressil http://localhost:8080
Logs - Avab logiakna, mis näitab lokaalse veebiserveri tegevust ning üleslaadimise olekut Linuxis näeb samu asju kohe peale mõne käivituskäsu sisestamist
SDK Console - Avab veebilehitsejas aplikatsiooni admin liidese lokaalses veebiserveris Linuxis tuleb veebilehitsejaga avada aadress http://localhost:8080/_ah/admin
Edit - Avab toimetamiseks aplikatsiooni peamise konfiguratsioonifaili Linuxis tuleb tekstiredaktoriga avada aplikatsiooni kataloogis fail app.yaml
Deploy - Laeb aplikatsiooni failid serverisse Linuxis tuleb käivitada käsklus appcfg.py update aplikatsiooni_kaust
Dashboard - Avab veebilehitsejas aplikatsiooni admin liidese Google serveris Linuxis tuleb avada aadress http://appengine.google.co m
Uue aplikatsiooniprojekti loomine Aplikatsioon koosneb aplikatsiooniprojektist, mis asub ühes kaustas ning koosneb minimaalselt määratud elementidest. Nendeks on kolm faili - app.yaml, mis määrab ära aplikatsiooni konfiguratsiooni, index.yaml andmebaasi indeksite seadmiseks ning main.py milles asub aplikatsioon ise. Graafilise SDK liidesega saab luua uue aplikatsiooniprojekti käsuga FileNew Application . Avanenud dialoogiaknas saab määrata aplikatsiooni ID ning projektifailide asukoha kataloogi . ID tohib sisaldada vaid ladina tähti, numbreid ja sidekriipsu. Kuigi programm ei anna veateadet kui nimi sisaldab näiteks tühikuid, siis hiljem seda programmi käivitada siiski ei saa.
9 / 55 Google App Engine ­ Andris Reinman
Linuxis saab uue projekti loomiseks kopeerida application_template kataloogist vajalikud failid sobivasse kohta ja kasutada neid lähtefailidena. Projekti ID tuleb seada app.yaml faili esimesel real , kus seisab application: myapp - seal tuleb myapp asendada mõne muu nimega. Esialgu muud ei olegi vaja - aplikatsiooni käivitades käsuga ,,Run" käivitatakse main.py failis olev näiteprogramm ning veebilehitsejas lokaalses veebiserveris aplikatsiooni aadressi avades tulebki ette lihtne teade - Hello world. Peale seda ongi selge, et kõik töötab.
Aplikatsiooni registreerimine appspot.com teenuses Kõik GAE aplikatsioonid tuleb reaalseks kasutamiseks registreerida http://www.appspot.com/ teenuse lehel. Peale registreerimist eraldatakse aplikatsioonile vajalik serveripind ning domeeninimi kujul aplikatsiooni_id.appspot.com. Enne aplikatsiooni registreerimist tuleb aktiveerida endale appspot.com konto , mida saab teha lihtsalt lehte külastades. Valmis peab olema mobiiltelefon , kuna kasutaja tuvastamine käib nimelt SMS teel (appspot.com saadab sisestatud mobiilinumbrile aktiveerimiskoodiga SMS-i). Registreerimine kujutab endast aplikatsiooni nime ehk ID määramist. Igal aplikatsioonil peab olema unikaalne ID ning see ID on kasutusel ka aplikatsiooni domeeninimes. Juhul kui app.yaml failis kirjas olev ID pole enam saadaval (aplikatsiooniprojekti luues polnud näiteks veel teada, et vastav ID on kinni), tuleb valida uus ID ning asendada see ka app.yaml failis.
Joonis 2. Aplikatsiooni registreerimine appspot.com lehel Lisaks on aplikatsiooni registreerimisel ka autentimisvalik. GAE nimelt sisaldab endas sisse- ehitatud Google autentimismoodulit, kus programmi looja ei pea ise pidama arvet kasutajate ning nende paroolide üle, vaid saab kasutada selleks Google Konto süsteemi. Aplikatsioon suunab kasutajad sisselogimiseks Google lehele ning Google teatab seejärel, kas kasutaja sai sisse logitud või mitte. Valikus saab siis määrata, et sisse saavad logida kasutajad kes a) on tavalised Google Konto
10 / 55 Google App Engine ­ Andris Reinman
kasutajad ja omavad näiteks GMail või Orkuti kasutajanime või siis alternatiivina b) kasutajate e- posti aadress peab olema kindla domeeni aadress. Viimasel juhul peab antud domeen olema registreeritud Google Apps (mitte segi ajada Google App Engine'ga) teenuses. Juhul kui aplikatsioon on edukalt registreeritud ning aplikatsiooni konfiguratsioonifailis app.yaml on kirjas ka korrektne aplikatsiooni ID, võib käivitada käsu ,,Deploy." Selle lõppedes peaks veebilehitseja näitama aadressil aplikatsiooni_id.appspot.com juba kohalikust veebiserverist tuttavat teadet - Hello World. Kõik on seega korrektselt seadistatud ning edasi saab tegeleda juba aplikatsiooni enda arendamisega.
app.yaml kasutamine
Ülesehitus Kõige olulisem fail mis määrab ära aplikatsiooni tegevuse, on app.yaml - selles failis on kirjas kõik tegevused, mida server mingile päringule vastab. Näiteks kui avatakse aadress domeen.appspot.com/abitekst, siis app.yaml teab, et /abitekst päringu peale tuleb käivitada fail abi.py, kui aga tuleb päring / tellimused , siis hoopis main.py. Samuti on selles failis ära määratud aplikatsiooni versiooninumber ( samast aplikatsioonist saab eksisteerida korraga mitu versiooni ning aplikatsiooni admin liidesest saab määrata, milline versioon on parasjagu aktiivne), käivituskeskkonna andmed (hetkel konstantsed) ning loomulikult aplikatsiooni ID. app.yaml, nagu faililaiendki määrab, on vormistatud YAML formaadis . See kujutab endast inimloetavat konfiguratsiooniteksti, kus andmed on vastavalt kontekstile trepitud. Näiterakenduse app.yaml sisu on järgmine:
application: myapp version : 1 runtime: python api_version: 1 handlers : - url: .* script : main.py Vaatame rida haaval üle, mis mida tähendab.
application: myapp Antud deklaratsioon paneb paika aplikatsiooni ID. Nagu öeldud, peab see olema unikaalne, koosnema vaid ladina tähtedest, numbritest ning sidekriipsust. Kui aplikatsiooni üles laadida, siis serveris vaadatakse just antud muutuja järgi, et kuhu failid kopeeritakse.
version: 1 See rida tähistab aplikatsiooni versiooni. Väärtus saab sarnaselt ID väärtusele sisaldada vaid ladina tähti, numbreid ja sidekriipsu. Juhul kui seda väärtust muuta, luuakse serveris aplikatsioonist uus versioon. Uus versioon ei muutu automaatselt aktiivseks, vaid see tuleb ise admin liidese abil aktiivseks seada. Aktiivset versiooni saab suvalisel hetkel ümber tõsta, valides selleks mõne varasema või uuema versiooni, mis serverisse laetud on. Kasulik on see juhul, kui uus versioon osutub näiteks liiga
11 / 55 Google App Engine ­ Andris Reinman
ebakindlaks. Sellisel juhul saab ajutiselt vanema versiooni taastada ning uue versiooni kallal veel veidi tööd teha. Kõiki olemasolevaid versioone saab vaadata veebis aadressilt kujul versiooni_nr.latest.app_id.appspot.com
runtime: python See rida märgib ära kasutatava programmeerimiskeele. Hetkel saab selleks määrata ainult väärtuse python, sest kuigi GAE võimaldab kasutada ka programmeermiskeelt Java, on sealne konfiguratsioonimeetod veidi teine ning app.yaml faili ei ole.
api_version: 1 See rida tähistab käivituskeskkonna versiooni, milleks momendil on ,,1"
handlers: Antud rida määrab ära, et edasi on defineeritud päringute haldajad. URL'i päringu osa võrreldakse etteantud mustrile ja vastavuse korral tagastatakse määratud fail (kas siis staatiline fail või käivitatav programm).
- url: .* Päringutingimuseks on, et päring peab vastama regulaaravaldisele .* - kuna .* tähistab suvalist stringi, siis lähevad selle tingimuse alla kõik päringud.
script: main.py Eelnenud tingimusele vastanud päring edastatakse programmile main.py. Päringutingimused käivad järjekorras ülevalt alla. Seega kui esimeseks tingimuseks on .* millele vastavad kõik päringud, siis sellest enam edasi ei vaadata. Kui aga on soov siiski täiendavaid kitsamaid tingimusi märkida, tuleks need teha enne .* tingimust näiteks nii:
handlers: - url: /abi script: abi.py - url: .* script: main.py Sellisel juhul proovitakse kõigepealt tingimust /abi, millele vastabki ainult aadress /abi ning alles siis kui päring sellele siiski ei vasta, antakse järjekord üle kontrolltingimusele .* Juhul kui päringule peaks vastama kindel staatiline fail, tuleks tingimus vormistada järgnevalt:
- url: /favicon.ico static_files: static/images/favicon.ico upload : static/images/favicon.ico See tingimus määrab ära, et favicon.ico pärimisele peaks vastama staatiline fail kataloogist static/images/favicon.ico Kui aga on soov defineerida terve kataloogitäis staatilisi faile, saab seda teha nii:
- url: /images static_dir: static/images Peale seda suunatakse kõik päringud kujuga /images/*.* (näiteks /images/ logo .jpg) edasi kataloogi static/images, kust otsitakse siis faili *.* (näite puhul siis logo.jpg) ning kui seda ei leita,
12 / 55 Google App Engine ­ Andris Reinman
tagastatakse veateade 404.
HTTP vs. HTTPS Iga päringutingimuse juures on võimalik määrata ära, kas seda päringut teostatakse üle tavalise HTTP ühenduse või turvalise HTTPS ühenduse. Vaikimisi on mõlemad ühendused lubatud, kuid on võimalik määrata ühene valik. HTTPS ühendus on võimalik ainult app_id.appspot.com domeenide korral - juhul kui teenus on seotud oma domeeniga (vaatad aplikatsiooni aadressilt www.app_id.ee, mitte app_id.appspot.com), siis sellisel juhul on võimalik kasutada vaid HTTP protokolli. HTTPS ühendus kasutab korrektset Google poolt allkirjastatud sertifikaati, mis kaasneb teenusega täiesti tasuta, seega ise vastavat sertifikaati kuskilt osta pole vaja.
- url: .* script: main.py secure: always Antud näites määrab secure:always, et HTTPS protokoll on alati kasutusel - juhul kui üritatakse avada veebilehte üle HTTP protokolli, suunatakse see HTTPS ühenduse peale ümber. secure parameetril saab olla kolm võimalikku väärtust: · always - alati kasutatakse HTTPS ühendust · never - alati kasutatakse HTTP ühendust · optional (vaikimisi) - lubatud on mõlemad ühendused Kuna HTTPS on oma olemuselt ressursimahukam (lisandub täiendav CPU kulu krüpteerimise jaoks), siis tasub seda kasutada vaid selge vajaduse korral. Lihtsalt niisama - igaks juhuks - seda peale panna pole mõtet.
Kohustuslik sisselogimine Täiendavalt on veel võimalik nõuda päringu teostamisel ka kasutaja sisselogimist . Kui sisselogimine on nõutav, siis päringu sooritamisel suunatakse kasutaja automaatselt sisselogimisvormi juurde (kasutades Google Konto süsteemi) juhul kui kasutaja pole juba sisse logitud. Nii on mugav panna mõningatele aadressidele, mida tavavaataja näha ei tohi, turvaline sisselogimise nõue. Sisselogimise tasemeid on 3. Esiteks avalik tase - sellisel juhul pole vaja login tingimust päringule lisada. Teiseks on tavakasutaja sisselogimise tase - nõutav on sisselogimine, olenevalt siis aplikatsiooni seadetest kas suvaline Google Konto kasutaja või kindla domeeniga Google Apps kasutaja. Viimane, kõige rangem tase lubab sisse logida vaid aplikatsiooni administraatoritel.
- url: .* script: main.py login: required Parameetri login väärtus võib seega olla · required - sobib iga sisseloginud kasutaja (vastavalt aplikatsiooni seadetele) · admin - sobivad ainult aplikatsiooni administraatorid Juhul kui sisselogimine pole nõutav, siis tuleb login parameeter ära jätta. Aplikatsiooni administraatoreid saab määrata aplikatsiooni administreerimise lehel (selle avab SDK graafilise liidese nupp ,,Dashboard") ,,Developers" alamlehelt. Aplikatsiooni looja on automaatselt ka aplikatsiooni administraator .
13 / 55 Google App Engine ­ Andris Reinman
Perioodilised tööd Google App Engine võimaldab seada perioodilisi töid ( cron ), mis käivitavad etteantud programmi ettemääratud intervalli järel. Näiteks saab määrata, et URL /tasks käivitub automaatselt igal keskööl või igal esmaspäeval kell kolm. Perioodiliste tööde määramiseks tuleb need tööd kirjeldada ära failis cron.yaml, mis asub samas kataloogis kus app.yaml failgi. Alguses projektis cron.yaml faili ei eksisteeri, vajadusel tuleb see ise luua. Perioodilise töö faili näide:
cron: - description: ülesanded url: /tasks schedule: every monday 09:00 timezone: Europe /Tallinn Cron päringu saab muuta juhuslikele külastajatele ligipääsmatuks, pannes selle parooli alla. app.yaml failis tuleks vastava päringu tingimustesse lisada rida secure:admin, kuna serveripoolne cron kasutaja on samuti aplikatsiooni administraatori õigustes. Juhul kui secure parameeter on seatud väärtusega login, siis cron töö ebaõnnestub, kuna tavakasutaja õigusi cron töödel pole. Perioodiliste tööde staatuseid (kas need on õnnestunud või mitte) saab vaadata aplikatsiooni administreerimise lehel (,,Dashboard") alamjaotuses ,,Cron Jobs".
Programmeermiskeel Python
Tutvustus Pythoni lõi kaheksakümnendate lõpul Guido van Rossum, kes on senimaani keele arengu peamiseks vedajaks. Google App Engine kasutab programmeerimiskeele Python versiooni 2.5 - kõik platvormile kirjutavad skriptid peavad seega olema antud versiooniga ühilduvad. Mainitud on, et tulevikus võib tekkida ka Python 3 tugi, kuid hetkel tuleb piirduda vaid olemasoleva versiooniga. Üheks peamiseks erisuseks teiste keeltega, näiteks võrrelduna teise levinud veebiprogrammeerimise keelega PHP, on loogiliste sulgude asemel blokkide defineerimine läbi visuaalse treppimise. PHP:
while(!$valmis){tee_midagi();} Python:
while not valmis:
14 / 55 Google App Engine ­ Andris Reinman
tee_midagi() Kuigi PHP-s kasutatakse tihtipeale koodi parema loetavuse nimel samuti sarnast treppimist, siis Pythoni puhul on see kohustuslik - programmi kõik blokid peavad olema korrektselt trepitud, vastasel korral annab interpretaator veateate. Treppida võib tühikute või tabeldusmärkidega - oluline on, et sama bloki laused on rea algusest sama kaugele joondatud. Puudu on ka lauset lõpetav semikoolon - kuna iga lause peab niikuinii olema treppimise tõttu korrektselt eraldi real, siis puudub spetsiaalsel lause lõpetamise sümbolil ka eriline mõte, selleks sobib täiesti hästi ka reavahetuse sümbol ise. Nagu ülevaolevast näitest näha, siis lõppevad blokki defineerivad laused avavate loogeliste sulgude asemel kooloniga , see on bloki alguse tunnusmärgiks. Bloki lõpul eraldi tunnust ei ole - kui järgneva rea lause taandub rea algusele lähemale, siis järelikult ongi blokk läbi.
for i in z: print i print "valmis" Näites kuulub lause print i bloki defineerinud for tsükli juurde, aga print "valmis" on juba sellest tsüklist väljas. Samuti on keele disaini puhul peetud silmas maksimaalset sarnasust inglise keelega. Sageli krüptilisusse kalduvate sümbolite nagu || või && asemel on kasutusel selgelt arusaadavad or ja and. Eitust märkiva hüüumärgi ! asendab ingliskeelne not. Erinevate lausete nagu tsüklid for ja while ning tingimuslause if puhul pole vaja tingimusi sisestada sulgude vahele, nii tekib ühe voolava lause tunne.
if a is not 5 and 6==7 or not b: tee_midagi() else : tee_midagi_muud()
Programmi struktuur Kui PHP puhul asub skript HTML või mõne muu väljundfaili sees - PHP koodiblokid tuleb muu väljundi vahel spetsiaalselt tähistada märgenditega - siis Pythoni skriptid on struktureeritud sarnased PERL keelele, kus terve fail ongi skriptifail ning koodiblokkide ja muu väljundi vahel PHP'le sarnast vahet teha ei saa. Juhul kui on soov midagi väljastada, tuleb teha seda näiteks print käsuga. Kõik skriptid algavad deklaratsiooniga, mis annavad keskkonnale teada skripti interpretaatori andmed ehk viite programmi juurde, kes antud faili käivitada oskab. Google App Engine puhul on selleks järgmine rida:
#!/usr/bin/env python Juhul kui skriptifail ei ole ISO-8859-1 ( Latin 1) vaid hoopis UTF-8 kodeeringus, siis tuleks see järgmisena (kohe teisel real) ära märkida. Nii teab Python 2.5 interpretaator millist kooditabelit kasutada.
# coding: utf-8 Järgmisena tuleks sisse laadida erinevad abistavad teegid, kuid seda saab teha vajadusel ka konkreetsete funktsioonide sees, mis antud teeke vajavad. Google App Engine puhul tuleks sisse
15 / 55 Google App Engine ­ Andris Reinman
laadida vajalikud teegid veebipäringute teenindamiseks . Selle jaoks on kasutusel WebAPP raamistik.
import wsgiref.handlers from google.appengine.ext import webapp Antud teekide poolt pakutavad meetodid oskavad vastu võtta app.yaml konfiguratsiooni poolt suunatud veebipäringuid (näiteks kui keegi avab aadressi www.server.ee/abi, siis /abi suunatakse skriptile ühe päringuna), leida nendest üles erinevad päringu andmed (GET ja POST muutujad, küpsised jne). Edasi tulevad konkreetsed päringute haldajad. Näitena on alljärgnevalt toodud ära minimaalne päringu haldaja nimega MainHandler, mis on laiendatud webapp.RequestHandler klassist ja saab seega kaasa vajalikud oskused päringuga ümber käia.
class MainHandler(webapp.RequestHandler): def get(self): self.response.out.write("Hello world!") Antud klass oskab vastata GET päringutele (selle jaoks on klassis meetod get) ning ainsa tegevusena väljastab päringu vastusena brauserile stringi Hello world. Viimasena tuleb seada üles milline päringu haldaja vastab millisele päringule. Vahet tehaks kasutatud URL'i järgi ning kasutada saab ka regulaaravaldisi.
def main(): application = webapp.WSGIApplication([('/', MainHandler)]) wsgiref.handlers.CGIHandler().run(application)
if __name__ == '__main__': main() Paksus kirjas on ära toodud massiiv , milles asuvadki sisendpäringute seosed konkreetsete haldajatega. Antud massiivil on seatud ainult üks element ja see vastab päringule / ehk siis domeeni juurkataloogile (näiteks http://www.server.ee/ ). Seega kui minimaalne Google App Engine Hello world kokku panna, oleks tulemus selline.
#!/usr/bin/env python # coding: utf-8
import wsgiref.handlers from google.appengine.ext import webapp
class MainHandler(webapp.RequestHandler): def get(self): self.response.out.write("Hello world!")
def main(): application = webapp.WSGIApplication([('/', MainHandler)]) wsgiref.handlers.CGIHandler().run(application)
if __name__ == '__main__': main() Edasi vaatame juba kõiki skriptis kasutatavaid osi omaette .
16 / 55 Google App Engine ­ Andris Reinman
Abiteekide laadimine Sarnaselt keelega PHP ei ole vaja Pythonis panna kogu kasutatavat programmikoodi ühte faili - täiendavad ja abistavad teegid saab vastavate lausetega teistest failidest programmikoodi sisse laadida. Kui PHP's on selle jaoks käsklus include , siis Pyhtonis on selle asemel import. import erineb PHP include käsust selle poolest, et kui include kasutab faili laadimiseks selle faili enda nime, siis import võtab sisendiks hoopis paketi nime. Sisuliselt on tegu samuti faili nimega, aga ilma faililaiendita ning kataloogi teeta .
import abiteek import teegid.abi import teegid.abi as abi from teegid.abi import tekst Esimene rida avab faili abiteek.py, mis asub laadiva skriptiga samas kataloogis. Järgmised kaks lauset impordivad skripti abi.py kataloogist teegid. Viimane lause impordib failist teegid/abi.py objekti tekst. Teegis olevate objektide kasutamise kuju määrabki ära import lause kuju. Nimelt tuleb objekti (olgu selleks objektiks siis mõni väärtus või funktsioon) nime ette lisada ka teegi nimi, kust see objekt pärineb. Juhul kui kasutame vormi import teegid.abi saabki teegi nimeks teegid.abi ja selles failis oleva objekti tekst väljastamiseks tuleb kõik pikalt välja kirjutada:
print teegid.abi.tekst Juhul kui teek on imporditud kujul import teegid.abi as abi, saab sama asja kirjutada lühema lausena
print abi.tekst Ja kui kasutatud on from...import kuju, on tulemus kõige lihtsam:
print tekst
Keele struktuurid
Muutujad ja andmetüübid Muutujad esitatakse nende nimelisel kujul ilma igasuguste prefiksiteta. Kui PHP's kirjeldatakse muutujaid kujul $nimi ja PERL'is on näiteks massiivid kujul %nimi, siis Pythonis piisab kõikide muutujate kirjeldamiseks kujust nimi. Muutujaid eelnevalt defineerida pole vaja, need luuakse vastavas skoobis esimese kasutuse korral automaatselt. Kehtib ka sulund, mis tähendab, et välises skoobis defineeritud muutuja on ligipääsetav ka sisemises skoobis. Seega programmi alguses väljaspool funktsioonide definitsioone loodud muutujad on ligipääsetavad ka allpool defineeritud funktsioonides, kuna funktsioonid on programmi põhivoo suhtes alamat laadi skoobid.
17 / 55 Google App Engine ­ Andris Reinman
Tekst Tekste saab hoida muutujates stringidena. Stringe määravad sarnaselt paljudele teistele keeltele jutumärgid " ja ülakomad '. Kui tekstis esineb täpitähti, tasub need vormistada UTF-8 sümbolitena, see aga thendab, et Pythonile tuleb teada anda stringi kodeering. Seda saab teha lisades stringi ette tähemärgi u.
tekst = u"see on UTF-8 tekst" print tekst Tekstide vormindamiseks saab kasutada mitmeid variante . Kõige lihtsam on stringide liitmine , mida saab teha operaatoriga +.
print u"Täna on " + kuu_nimi Tihtipeale on mugavam kasutada aga spetsiaalselt vormindamisoperaatorit %.
print u"Täna on %s" % kuu_nimi Mitme elemendi korral saab antud operaatorit kasutada nii:
print u"Täna on %s ja aasta on %s" % (kuu_nimi, aasta_nr) Sellise avaldise tulemusena väljastataks Täna on jaanuar ja aasta on 2010
Numbrid Sarnaselt PHP'ga numbritüüpi (näiteks double , float, word, integer jne) eraldi defineerida pole vaja ning numbreid saab kohe kasutama hakata. Probleemiks võib vaid osutuda erinevate arvude jagamine, kuna juhul kui Python peab numbrit mida jagatakse täisarvuks (integer), siis tulemuseks saab samuti täisarv ning murdosa lõigatakse lihtsalt ära. Seega tuleb jagamise hetkeks number ujukomaarvuks teisendada
7 / 2 = 3 7.0 / 2 = 3.5 float(7) / 2 = 3.5
Massiivid Massiivide kirjeldamiseks on sarnaselt JavaScript massiividele nurksulud ning nende sees on elemendid eraldatud komadega . Massiivide pikkused pole määratud, st. et nendele saab vajadusel alati liikmeid juurde lisada. Elementide indeksid algavad numbrist 0.
massiiv = [u"tere", u"kuidas", u"läheb"] Näites on defineeritud massiiv kolme elemendiga tere, kuidas ja läheb. Juhul kui on soov opereerida esimese elemendiga, saab seda teha samuti läbi nurksulgude, mis lisatakse muutuja järele.
print massiiv[0]
Assotsiatiivsed massiivid Kui tavamassiivide indeksid on numbrilised ja lähevad järjest, siis assotsiatiivsed massiivid on tekstiliste indeksitega massiivid. Sellise massiivi defineerimiseks saab kasutada loogelisi sulge .< Vütmete nimed peavad olema jutumärkides. Kasutada saab sellise massiivi elemente sarnaselt tavamassiividega:
print objekt["võti"]
Tsüklid
FOR tsükkel FOR tsükkel Pythonis kujutab endast midagi PHP foreach tsükli laadset . Tsükli üheks parameetriks on massiiv või mõni loendatav objekt, millest võetakse ükshaaval elemente ja omistatakse need muutuja väärtuseks, kuni massiivi elemendid on kõik läbi käidud.
for väärtus in massiiv: print väärtus Näide väljastab ükshaaval massiivi kõikide elementide väärtused. Lisaks väärtustele saab pärida ka võtmete nimetusi, eriti oluline on see objektide juures, kus võtmed ei pruugi olla numbrilised.
for võti, väärtus in loendatav_objekt: print u"võtme %s väärtuseks on %s" % (võti, väärtus)
WHILE tsükkel WHILE tsüklit täidetakse seni, kuni tsüklitingimus pole enam täidetud.
loendur = 0 while loendur