Hurtig Tips Bruke Google App Engine som proxy server

Google App Engine kan brukes som en fri og praktisk måte rundt restriktiv eller manglende kryp domenepolitikkfiler. Denne opplæringen vil vise deg hvordan du oppretter en GAE-proxy som gir tilgang til begrensede ressurser for Flash-applikasjonen.

Endelig resultatforhåndsvisning

La oss se på det endelige resultatet vi vil jobbe for:

Det har bare blitt sendt noen testdata til et eksternt regneark som er hostet på Google Dokumenter. Dette ville ikke fungere uten en crossdomain.xml-fil på mottakerdomene - likevel tillater ikke kryssdomenepolitikkfilen på Google Dokumenter dette, og jeg kan ikke endre det. Les videre for å finne ut hvordan dette ble gjort.

Hvorfor bruke en proxy?

I min siste Quick Tip En veiledning for krypteringspolitikkfiler viste jeg deg hvordan kryssdomenepolitikkfiler brukes av Flash for å finne ut hvilke data som kan nås fra eksterne domener. Selv om du er i stand til å kontrollere tilgangen til ressurser, er det bra for administratorer, det er en smerte for Flash-utviklere som prøver å få tilgang til data på en server som ikke har en kryssdomenepolitikkfil, siden ingen policyfil betyr ingen tilgang. Konfigurere en kryssdomenepolitikkfil kan enkelt overses, og jeg har gått inn i flere enn en nettleverandør som ikke trodde å imøtekomme for Flash-utviklere.

Jeg nevnte også at problemet var lett omgått ved bruk av en proxy. Ideen bak en proxy er at den vil akseptere tilkoblinger fra eksterne Flash-applikasjoner (ved å levere riktig crossdomain.xml-fil), og deretter fungere som en mellomledd som sender data frem og tilbake. Det eneste virkelige kravet til en proxy-server (som det gjelder Flash) er at den skal kunne få tilgang til offentlige ressurser uavhengig av tillatelsene som kanskje eller ikke er gitt av en kryssdomenepolicy.

De virkelig gode nyhetene er at du kan sette opp en slik proxy uten oppe kostnader ved hjelp av Google App Engine (GAE). GAE vil være vert for et webprogram, og forutsatt at trafikkkravene er under terskelen, er det ingen kostnad. Det jeg vil demonstrere her er hvordan du lager et enkelt GAE-webprogram som kan fungere som en proxy, slik at Flash-applikasjoner kan få tilgang til ressurser som ellers ville være utenfor grenser.

Trinn 1: Google Regneark og Dreaded crossdomain.xml

Det er en veldig pen funksjon i Google Dokumenter som lar deg lage et webskjema som kan brukes til å fylle et regneark. Jeg har satt opp et slikt skjema her, med resultatene av dette skjemaet publisert som en offentlig nettside her. Skjemaet er et standard HTML-skjema, som kan sendes programmatisk ved hjelp av en standard HTTP POST-operasjon.

Jeg var nylig i en posisjon der jeg trengte å samle inn tilbakemelding fra en Flash-applikasjon jeg hadde distribuert. Disse skjemaene virket som en fin måte å gjøre det på. Det var ingen hostingkostnader for meg, resultatene kunne enkelt analyseres direkte av regnearket, og jeg kunne være ganske sikker på at en Google-tjeneste som Docs ville være pålitelig. Det eneste problemet var korsdomenepolitikken.

Denne bestemte policyfilen tillater ikke tilgang til http://spreadsheets.google.com/ domenet for eksterne Flash-programmer. Og sikkert, hvis du prøver å sende inn et skjema programmatisk fra Flash, vil det mislykkes.

Dette er et perfekt eksempel hvor en proxy kan hjelpe.

Trinn 2: Lag en GAE-applikasjon

Registrer deg for en App Engine-konto. Du vil bli bedt om å opprette en ny applikasjon. Her har jeg opprettet et program som heter activetutsproxydemo. Du må velge ditt eget unike programnavn.

Trinn 3: Få GAE SDK

Last ned og installer App Engine SDK. Dette vil installere et program kalt Google App Engine Launcher. Kjør det og klikk Fil | Opprett nytt program ...

Skriv inn navnet på programmet du opprettet i trinn 1, velg et sted for programmets filer som skal lagres, og klikk på Skape knapp.

Trinn 4: Endre main.py-filen

Google App Engine Launcher vil opprette et standardprogram for deg i katalogen du angav. Du bør se en fil som heter main.py. Overskriv innholdet i denne filen med følgende Python-kode:

 fra google.appengine.ext import webapp fra google.appengine.ext.webapp.util import run_wsgi_app import urllib fra google.appengine.api import urlfetch klasse GoogleForm (webapp.RequestHandler): def post (selv): destinationURL = "http: / /spreadsheets.google.com/formResponse?formkey=dHh4VTRVbGtSM3ZycUtpbEFKSUJ2Znc6MA&ifq "form_fields = " entry.0.single ": self.request.get ('entry.0.single')," entry.1.single ": self.request .get ('entry.1.single'), 'entry.2.single': self.request.get ('entry.2.single'), 'entry.3.single': self.request.get (' oppføring.3.single '), "pageNumber": "0", "backupCache": "", "send": "Send" form_data = urllib.urlencode (form_fields) result = urlfetch.fetch (url = destinationURL, nyttelast = form_data, method = urlfetch.POST, headers = 'Content-Type': 'application / x-www-form-urlencoded') Skriv ut resultatklasse CrossDomain (webapp.RequestHandler): def get (selv): self.response .headers ['Content-Type'] = 'text / xml' self.response.out.write ("" "   ("/crossdomain.xml ', CrossDomain)], debug = True) def main (): run_wsgi_app (søknad) hvis __name__ ==" __main__ ": main ()

Du finner mer informasjon om hvordan denne koden fungerer i GAE-dokumentasjonen, men jeg vil fremheve viktige biter her.

Denne linjen sier at GoogleForm klassen vil bli utført når http://youapplicationname.appspot.com/googleform adressen er tilgjengelig, og CrossDomain klassen vil bli utført når http://youapplicationname.appspot.com/crossdomain.xml adressen er tilgjengelig.

søknad = webapp.WSGIApplication ([('/ googleform', GoogleForm), ('/crossdomain.xml', CrossDomain)], debug = True)

De CrossDomain klassen vil utgjøre en kryssdomenepolitikkfil som gir full tilgang til domenet ved hjelp av eksterne Flash-applikasjoner.

 klassen CrossDomain (webapp.RequestHandler): def get (selv): self.response.headers ['Content-Type'] = 'text / xml' self.response.out.write ("" "   "" ")

De GoogleForm klassen brukes til å sende innkommende HTTP POST-forespørsel til Google Dokumenter-skjemaet.

klasse GoogleForm (webapp.RequestHandler): def post (selv):

De destinationUrl variabel definerer nettadressen som skjemaet skal legge inn til (nei, dette er ikke det samme som nettadressen som ble brukt til å vise skjemaet, men snarere nettadressen tildelt til skjema tag handling Egenskap.

destinationURL = "http://spreadsheets.google.com/formResponse?formkey=dHh4VTRVbGtSM3ZycUtpbEFKSUJ2Znc6MA&ifq"

De form_fields variabel kart de innkommende HTTP POST-variablene med de som må leveres til Google-skjemaet.

form_fields = "entry.0.single": self.request.get ('entry.0.single'), "entry.1.single": self.request.get ('entry.1.single'), " entry.2.single ": self.request.get ('entry.2.single'), 'entry.3.single': self.request.get ('entry.3.single')," pageNumber ":" 0 "," backupCache ":" "," send ":" Send "

Dataene i feltene er URL-kodet. Dette er litt overflødig, fordi de allerede skal kodes av Flash-applikasjonen når de sendes, men det gjør ikke vondt for å være sikker.

form_data = urllib.urlencode (form_fields)

Dataene blir deretter POSTed til Googles tjenere, og resultatet blir lagret i resultat variabel.

result = urlfetch.fetch (url = destinationURL, nyttelast = form_data, metode = urlfetch.POST, overskrifter = 'Content-Type': 'application / x-www-form-urlencoded')

Resultatet skrives deretter ut, noe som medfører at det sendes tilbake til Flash-applikasjonen.

utskriftsresultat

Trinn 5: Last opp programmet

Velg ditt GAE-program i Google App Engine Launcher, og klikk på Implementer-knappen.

Du vil be om Google-legitimasjon, og deretter vil programmet bli lastet opp.

Trinn 6: Test ditt program

Gå til http://yourapplicationname.appspot.com/crossdomain.xml (du kan se min crossdomain.xml-fil her). Hvis alt gikk bra, bør du se en XML-fil (du må kanskje se sidekilden for å se policyfilen).

Hvis du ser noe som ligner på bildet ovenfor, er din GAE webapplikasjon oppe.

Trinn 7: Få tilgang til skjemaet med Flex

MXML-filen nedenfor er et eksempel på hvordan du gjør en HTTP POST-handling ved hjelp av HTTPService klasse.

De variabler variabel kart thePOST variable navn til dataene som vil bli sendt.

var-variabler: Objekt = nytt objekt (); variabler ["entry.0.single"] = "test0"; variabler ["entry.1.single"] = "test1"; variabler ["entry.2.single"] = "test2"; variabler ["entry.3.single"] = "test3";

Deretter oppretter vi en ny forekomst av HTTPService klasse.

var service: HTTPService = ny HTTPService ();

Vi må spesifisere hvilken nettadresse vi skal poste til. For denne første testen vil vi prøve å POSTe til Google-skjemaet direkte. Dette vil faktisk mislykkes, men det er en god demonstrasjon av hvorfor vi må bruke en proxy i utgangspunktet.

service.url = "http://spreadsheets.google.com/formResponse?formkey=dHh4VTRVbGtSM3ZycUtpbEFKSUJ2Znc6MA&ifq";

Vi forteller HTTPService protesterer på at vi forventer ren tekst som svar.

service.resultFormat = HTTPService.RESULT_FORMAT_TEXT;

Vi må også fortelle HTTPService objektiver at vi ønsker å utføre en HTTP POST-operasjon.

service.method = "POST";

Noen hendelseshåndterere er satt opp for å fortelle oss om operasjonen var vellykket eller ikke.

service.addEventListener (ResultEvent.RESULT, funksjon (event: ResultEvent): void Alert.show ("Data ble sendt med hell!");); service.addEventListener (FaultEvent.FAULT, funksjon (event: FaultEvent): void Alert.show ("Det oppstod en feil!";;);

Til slutt sender vi dataene av.

service.send (variabler);

Trinn 8: Samle applikasjonen

Hvis du kompilerer og kjører programmet ved hjelp av knappen med den grønne pilen på den, vil du oppdage at den faktisk fungerer.

Så hva er big deal? Hvorfor gå til alle problemer med å skape en proxy? Vel, programmet vil fungere på din lokale maskin, fordi / bin-debug / katalogen der Flex plasserer den sammensatte SWF, er en pålitelig plassering. Dette betyr at programmet vil kunne få tilgang til Google-serveren. For å simulere hvordan applikasjonen ville fungere på et nettsted selv om du trenger å kompilere en utgivelsesversjon.

Nå, når du kjører SWF fra / bin-release / mappen, vil du se at operasjonen har feilet. Slik fungerer SWF når den lastes opp til et nettsted.

Trinn 9: Bruke proxyen

Bruk av GAE-proxy er et enkelt tilfelle av endring av nettadressen som er tildelt til HTTPService gjenstand.

service.url = "http://activetutsproxydemo.appspot.com/googleform";

Nå når du kjører programmet, enten fra bin-debug eller bin-release kataloger, vil operasjonen bli fullført.

Konklusjon

Hvis du oppretter et Google App Engine-proxy-program, kan du enkelt få tilgang til ressurser på servere som ellers ville utelukke Flash-programmer. Så lenge søknaden din ikke ber om enorme ressurser, bør du oppdage at du ikke vil krysse terskelene for gratis GAE-tjenesten.

Men vær ikke fristet til å skape en mer generalisert proxy. Selv om det ville være mulig å opprette en proxy som brukte en spesiell variabel for å bestemme destinasjonsadressen, slik at programmet kunne opptre som en proxy for en ressurs, ville en slik server raskt bli utnyttet av andre utviklere. Her har vi hardt kodet destinasjonsadressen, noe som betyr at det i verste fall kan noen bruke denne proxyen til å sende data til Google Dokumenter-skjemaet. Dette gjør det lite nytt for noen andre, og reduserer sannsynligheten for at tjenesten vil bli misbrukt.

Jeg håper du likte denne opplæringen, takk for å lese!

Kode