Google Cloud Functions: Átfogó útmutató a HTTP triggerekhez

A Google Cloud Functions (GCF) egy szerver nélküli végrehajtási környezet, amely lehetővé teszi felhőszolgáltatások létrehozását és összekapcsolását. A Cloud Functions segítségével egyszerű, célorientált függvényeket írhat, amelyek a felhőinfrastruktúrából és szolgáltatásokból kibocsátott eseményekhez kapcsolódnak. A függvény akkor kerül végrehajtásra, amikor a megfigyelt esemény bekövetkezik. Ez a megközelítés lehetővé teszi eseményvezérelt alkalmazások fejlesztését szerverek vagy futtatókörnyezetek kezelése nélkül.

A Cloud Function aktiválásának egyik leggyakoribb módja egy HTTP-kérés. Ez az útmutató elmélyül a Google Cloud Functions HTTP-triggerjeinek világában, és felvértezi Önt a hatékony, méretezhető és költséghatékony alkalmazások létrehozásához szükséges tudással.

Mik azok a HTTP triggerek?

A HTTP trigger lehetővé teszi, hogy a Cloud Function-t egy HTTP-kérésre válaszul hajtsa végre. Lényegében, amikor egy HTTP-kérést küldenek egy adott URL-re, a Google Cloud Functions automatikusan végrehajtja a hozzá tartozó függvényt. Ezáltal a HTTP triggerek ideálisak API-k, webhookok és eseményvezérelt webalkalmazások létrehozásához.

A HTTP triggerek használatának fő előnyei:

• Méretezhetőség: A Cloud Functions automatikusan méreteződik a bejövő HTTP-kérések kezelésére. Nem kell aggódnia a szerverek kiépítése vagy kezelése miatt.
• Költséghatékonyság: Csak a függvény futási idejéért fizet. Amikor a függvény tétlen, nem merülnek fel költségek.
• Könnyű használat: A Cloud Functions leegyszerűsíti a fejlesztési és telepítési folyamatot. A függvénykód megírására koncentrálhat, a Google Cloud pedig gondoskodik az infrastruktúráról.
• Integráció: A HTTP triggerek lehetővé teszik a Cloud Functions egyszerű integrálását más szolgáltatásokkal, például webalkalmazásokkal, mobilalkalmazásokkal és harmadik féltől származó API-kkal.

Cloud Function létrehozása HTTP triggerrel

Nézzük végig egy egyszerű Cloud Function létrehozásának folyamatát egy HTTP triggerrel. Létrehozunk egy függvényt, amely egy "Hello, World!" üzenettel válaszol. Ez a példa különféle globális helyekhez adaptálható az output string egyszerű módosításával.

Előfeltételek:

• Egy Google Cloud Platform (GCP) fiók.
• A Google Cloud SDK (gcloud) telepítve és konfigurálva.

Lépések:

1. Új projekt létrehozása (ha még nincs):

   Ha még nincs GCP-projektje, hozzon létre egyet a Google Cloud Console-ban.

2. A Cloud Functions API engedélyezése:

   A Cloud Console-ban navigáljon a Cloud Functions API-hoz, és engedélyezze azt.

3. Függvénykönyvtár létrehozása:

   Hozzon létre egy új könyvtárat a Cloud Function számára. Például:

               mkdir hello-http
   cd hello-http
               
   
                 
                   Copy
                 
               
             

4. A függvénykód megírása:

   Hozzon létre egy `main.py` (vagy `index.js` Node.js esetén) nevű fájlt a következő kóddal:

   Python (main.py):

               def hello_http(request):
       """HTTP Cloud Function.
       Args:
           request (flask.Request): The request object.
           
       Returns:
           The response text, or any set of values that can be turned into a
           Response object using `make_response`
           .
       """
       request_json = request.get_json(silent=True)
       request_args = request.args
   
       if request_json and 'name' in request_json:
           name = request_json['name']
       elif request_args and 'name' in request_args:
           name = request_args['name']
       else:
           name = 'World'
       return f'Hello, {name}!'
               
   
                 
                   Copy
                 
               
             

   Node.js (index.js):

               exports.helloHttp = (req, res) => {
     let name = 'World';
     if (req.body.name) {
       name = req.body.name;
     } else if (req.query.name) {
       name = req.query.name;
     }
     res.status(200).send(`Hello, ${name}!`);
   };
               
   
                 
                   Copy
                 
               
             

5. Követelményfájl létrehozása (csak Python esetén):

   Ha Pythont használ, hozzon létre egy `requirements.txt` nevű fájlt, és adja hozzá a függvényhez szükséges függőségeket. Ebben a példában erre nincs feltétlenül szükség, de jó gyakorlat egyet mellékelni. Üresen hagyhatja, ha nincsenek függőségei.

6. A függvény telepítése:

   Használja a `gcloud functions deploy` parancsot a függvény telepítéséhez. Cserélje ki a `YOUR_FUNCTION_NAME` elemet a függvény kívánt nevére.

   Python:

               gcloud functions deploy YOUR_FUNCTION_NAME \
       --runtime python39 \
       --trigger-http \
       --allow-unauthenticated
               
   
                 
                   Copy
                 
               
             

   Node.js:

               gcloud functions deploy YOUR_FUNCTION_NAME \
       --runtime nodejs16 \
       --trigger-http \
       --allow-unauthenticated
               
   
                 
                   Copy
                 
               
             

   Paraméterek magyarázata:

   • `YOUR_FUNCTION_NAME`: A Cloud Function-nek adni kívánt név.
   • `--runtime`: A függvény futási környezete (pl. `python39`, `nodejs16`).
   • `--trigger-http`: Megadja, hogy a függvényt HTTP-kérések indítsák el.
   • `--allow-unauthenticated`: Lehetővé teszi, hogy bárki hitelesítés nélkül meghívja a függvényt. Figyelem: Legyen óvatos, ha ezt éles környezetben engedélyezi! Fontolja meg a megfelelő hitelesítés és engedélyezés megvalósítását.
7. A függvény tesztelése:

   A telepítés után a `gcloud` parancs kiadja a függvény URL-jét. Ezután tesztelheti úgy, hogy HTTP-kérést küld erre az URL-re egy olyan eszközzel, mint a `curl` vagy a Postman.

               curl YOUR_FUNCTION_URL
               
   
                 
                   Copy
                 
               
             

   A válaszban a "Hello, World!" üzenetnek kell megjelennie. Nevezhet meg egy nevet lekérdezési paraméterként is:

               curl "YOUR_FUNCTION_URL?name=YourName"
               
   
                 
                   Copy
                 
               
             

   Ennek a következőt kell visszaadnia: "Hello, YourName!"

A HTTP-kérés és -válasz értelmezése

Amikor egy Cloud Function egy HTTP-kérés indítja el, egy objektumot kap, amely információkat tartalmaz a kérésről. Ez az objektum általában a következőket tartalmazza:

• Fejlécek: A kéréshez küldött HTTP-fejlécek.
• Törzs: A kérés törzse (pl. JSON-adatok, űrlapadatok).
• Lekérdezési paraméterek: Az URL-ben átadott paraméterek.
• Módszer: A HTTP-módszer (pl. GET, POST, PUT, DELETE).

A függvénynek ezután egy HTTP-választ kell visszaadnia, amely a következőket tartalmazza:

• Állapotkód: A HTTP-állapotkód (pl. 200 OK, 400 Bad Request, 500 Internal Server Error).
• Fejlécek: A válaszhoz küldendő HTTP-fejlécek.
• Törzs: A válasz törzse (pl. JSON-adatok, HTML-tartalom).

Példa: Különböző HTTP-módszerek kezelése

Íme egy példa arra, hogyan kezelheti a különböző HTTP-módszereket a Cloud Function-ben:

Python (main.py):

            from flask import escape

def http_method(request):
    """Responds to any HTTP request.
    Args:
        request (flask.Request): HTTP request object.
    Returns:
        The response text or any set of values that can be turned into a
        Response object using
        `make_response`.
    """
    if request.method == 'GET':
        return 'This is a GET request!'
    elif request.method == 'POST':
        request_json = request.get_json(silent=True)
        if request_json and 'message' in request_json:
            message = escape(request_json['message'])
            return f'This is a POST request with message: {message}'
        else:
            return 'This is a POST request without a message.'
    else:
        return 'Unsupported HTTP method.', 405

            

              
                Copy
              
            
          

Node.js (index.js):

            exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('This is a GET request!');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`This is a POST request with message: ${message}`);
      } else {
        res.status(200).send('This is a POST request without a message.');
      }
      break;
    default:
      res.status(405).send('Unsupported HTTP method!');
      break;
  }
};
            

              
                Copy
              
            
          

Ne felejtse el telepíteni a frissített függvényt a `gcloud functions deploy` paranccsal.

A HTTP triggerek védelme

A biztonság kiemelten fontos a HTTP triggerekkel való munkavégzés során, különösen akkor, ha érzékeny adatokkal vagy kritikus műveletekkel foglalkozik. Íme néhány fontos biztonsági szempont:

Hitelesítés és engedélyezés

Alapértelmezés szerint a HTTP által aktivált Cloud Functions nyilvánosan elérhetők, ha a `--allow-unauthenticated` paramétert használja. A legtöbb éles forgatókönyvben korlátozni szeretné a hozzáférést a jogosult felhasználókra vagy szolgáltatásokra. A Google Cloud számos lehetőséget kínál a hitelesítéshez és az engedélyezéshez:

• Identity-Aware Proxy (IAP): Az IAP lehetővé teszi a Cloud Functions-hez való hozzáférés szabályozását a Google-identitások alapján. Megköveteli, hogy a felhasználók a Google-fiókjukkal hitelesítsék magukat, mielőtt hozzáférnének a függvényhez.
• Szolgáltatásfiókok: Hozzárendelhet egy szolgáltatásfiókot a Cloud Function-hez, és használhatja azt más Google Cloud-szolgáltatásokkal való hitelesítéshez. Ez hasznos, ha engedélyezni szeretné, hogy a függvény hozzáférjen olyan erőforrásokhoz, mint a Cloud Storage vagy a Cloud Datastore.
• Egyéni hitelesítés: Megvalósíthatja saját hitelesítési mechanizmusát, például JWT-t (JSON Web Token) vagy API-kulcsokat. Ez a legnagyobb rugalmasságot biztosítja, de több fejlesztési erőfeszítést is igényel.

Beviteli adatok érvényesítése

Mindig ellenőrizze a Cloud Function által fogadott bemeneti adatokat, hogy megakadályozza a biztonsági réseket, például az SQL-injektálást vagy a cross-site scriptinget (XSS). Használjon megfelelő tisztítási és kódolási technikákat a rosszindulatú bemenetek elleni védelemhez.

HTTPS

Győződjön meg arról, hogy a Cloud Function csak HTTPS-en keresztül érhető el az ügyfél és a függvény közötti kommunikáció titkosításához. A Google Cloud Functions automatikusan biztosítja a HTTPS-végpontokat.

Sebességkorlátozás

Valósítson meg sebességkorlátozást a visszaélések és a szolgáltatásmegtagadási (DoS) támadások megelőzése érdekében. Használhat olyan szolgáltatásokat, mint a Google Cloud Armor, hogy megvédje a Cloud Functions-t a túlzott forgalomtól.

A HTTP triggerek használati esetei

A HTTP triggerek sokoldalúak, és sokféle alkalmazásban használhatók. Íme néhány gyakori használati eset:

• REST API-k: Hozzon létre RESTful API-kat webes és mobilalkalmazásaihoz.
• Webhookok: Integráljon harmadik féltől származó szolgáltatásokkal webhook események fogadásával.
• Űrlapfeldolgozás: HTML-űrlapokon keresztül beküldött adatok feldolgozása.
• Képátméretezés: Képátméretezés elindítása, amikor új képeket töltenek fel a Cloud Storage-ba.
• Adattranszformáció: Adatok átalakítása egyik formátumból a másikba.
• Slack botok: Interaktív Slack botok létrehozása.
• Egyéni webalkalmazások: Dinamikus tartalom kiszolgálása kis webalkalmazásokhoz vagy mikroszolgáltatásokhoz.

Példák különböző iparágakból

• E-kereskedelem (Globális): A HTTP triggert használhatjuk a fizetések feldolgozására a világ különböző fizetési átjáróiból, a tranzakciók validálására és a rendelési állapotok valós időben történő frissítésére. A függvény használhatja a kérésből származó földrajzi helymeghatározási információkat a megfelelő adók és szállítási költségek alkalmazásához a felhasználó tartózkodási helye alapján.
• Pénzügy (Nemzetközi banki szolgáltatások): A HTTP triggerek megkönnyíthetik a biztonságos pénzátutalásokat a különböző bankszámlák között világszerte, kezelve a pénznemek átváltását és betartva a nemzetközi banki előírásokat. A hitelesítés itt kulcsfontosságú, potenciálisan többfaktoros hitelesítést is magában foglalva SMS-en vagy hitelesítő alkalmazásokon keresztül.
• Egészségügy (Telemedicina): A HTTP trigger kezelheti a betegek időpontfoglalási kérelmeit a világ minden tájáról, koordinálva a különböző időzónákat és kezelve az orvosok elérhetőségét. Integrálható fordítószolgáltatásokkal is a többnyelvű támogatás biztosítása érdekében. Az adatvédelem és a HIPAA (az Egyesült Államokban) vagy a GDPR (Európában) előírásainak való megfelelés kiemelten fontos.
• Oktatás (Online tanulási platformok): A HTTP triggerek felhasználhatók a feladatok automatikus osztályozására, azonnali visszajelzést adva a tanulóknak, függetlenül a tartózkodási helyüktől. Személyre szabott tanulási javaslatokat is kiválthatnak a tanulók teljesítménye alapján.
• Logisztika (Globális szállítás): A HTTP triggerek felhasználhatók a szállítmányok valós időben történő nyomon követésére, frissítéseket biztosítva a csomag helyéről és a becsült szállítási időről az ügyfelek számára világszerte. A különböző szállítmányozó cégekkel való integráció a HTTP triggereken keresztül az API-jaik használatával gyakori.

Haladó technikák

Környezeti változók használata

A környezeti változók lehetővé teszik a Cloud Function konfigurálását anélkül, hogy érzékeny információkat vagy konfigurációs értékeket kódolna a kódba. A környezeti változókat a `gcloud functions deploy` paranccsal vagy a Google Cloud Console-ban állíthatja be.

            gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=YOUR_API_KEY,DATABASE_URL=YOUR_DATABASE_URL
            

              
                Copy
              
            
          

A kódban hozzáférhet a környezeti változókhoz az `os.environ` szótár (Python) vagy a `process.env` objektum (Node.js) segítségével.

Python:

            import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Use the API key in your function
    return f'API Key: {api_key}'
            

              
                Copy
              
            
          

Node.js:

            exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Use the API key in your function
  res.status(200).send(`API Key: ${apiKey}`);
};
            

              
                Copy
              
            
          

Aszinkron feladatok kezelése

Hosszú ideig futó vagy számításigényes feladatok esetén a legjobb az aszinkron feldolgozást használni a HTTP-kérés blokkolásának elkerülése érdekében. Használhat olyan szolgáltatásokat, mint a Google Cloud Tasks vagy a Cloud Pub/Sub, hogy ezeket a feladatokat külön sorokba helyezze át.

Hibakezelés és naplózás

Valósítson meg robusztus hibakezelést és naplózást a Cloud Functions-ben a problémák gyors azonosításához és megoldásához. Használja a Google Cloud Loggingot a függvények naplóinak gyűjtéséhez és a teljesítményük figyeléséhez.

Gyakorlati tanácsok

• Tartsa a függvényeket kicsinek és célzottnak: Minden függvénynek egyetlen, jól definiált célja legyen.
• Függőségkezelés használata: Használjon csomagkezelőket, például `pip` (Python) vagy `npm` (Node.js) a függőségek kezeléséhez.
• Alaposan tesztelje a függvényeket: Írjon egységteszteket és integrációs teszteket, hogy megbizonyosodjon arról, hogy a függvények megfelelően működnek.
• A függvény teljesítményének figyelése: Használja a Google Cloud Monitoringot a függvény végrehajtási idejének, memóriahasználatának és hibarátájának nyomon követéséhez.
• Kód optimalizálása a hidegindításokhoz: Minimalizálja a függvény indításához szükséges időt (hidegindítás). Ez a függőségek csökkentésével, a kód optimalizálásával és a kiépített konkurens használatával érhető el (ahol elérhető).
• Fontolja meg a függvény helyét: Helyezze üzembe a függvényeket egy olyan régióban, amely földrajzilag közel van a felhasználókhoz a késleltetés minimalizálása érdekében. Globális közönség esetén fontolja meg a több régióba történő üzembe helyezést.

Gyakori problémák hibaelhárítása

• A függvény telepítése sikertelen: Ellenőrizze a kód szintaktikai hibáit, győződjön meg arról, hogy rendelkezik a szükséges engedélyekkel, és ellenőrizze, hogy támogatott futtatókörnyezetet használ-e.
• A függvény 500-as hibát ad vissza: Ellenőrizze a Google Cloud Logging függvény naplóit a hibaüzenetekért. Gyakori okok a kezeletlen kivételek, a hiányzó függőségek vagy a helytelen konfiguráció.
• A függvény túllépi az időkorlátot: Növelje a függvény időkorlát értékét a Google Cloud Console-ban vagy a `gcloud functions deploy` paranccsal. Ezenkívül optimalizálja a kódot a végrehajtási idő csökkentése érdekében.
• A függvény nem indul el: Ellenőrizze, hogy a trigger helyesen van-e konfigurálva, és hogy a HTTP-kérés a megfelelő URL-re van-e elküldve.

Következtetés