Google Cloud Functions: Een uitgebreide handleiding voor HTTP-triggers

Google Cloud Functions (GCF) is een serverloze uitvoeringsomgeving waarmee u cloudservices kunt bouwen en verbinden. Met Cloud Functions schrijft u eenvoudige, functies met een enkel doel die zijn gekoppeld aan gebeurtenissen die worden gegenereerd vanuit uw cloudinfrastructuur en -services. Uw functie wordt uitgevoerd wanneer de gebeurtenis die u in de gaten houdt, plaatsvindt. Met deze aanpak kunt u event-gestuurde applicaties ontwikkelen zonder servers of runtimes te beheren.

Een van de meest voorkomende manieren om een Cloud Function te activeren, is via een HTTP-verzoek. Deze handleiding duikt in de wereld van HTTP-triggers in Google Cloud Functions en biedt u de kennis om krachtige, schaalbare en kosteneffectieve applicaties te bouwen.

Wat zijn HTTP-triggers?

Met een HTTP-trigger kunt u uw Cloud Function uitvoeren als reactie op een HTTP-verzoek. In wezen, wanneer een HTTP-verzoek naar een specifieke URL wordt verzonden, voert Google Cloud Functions automatisch de bijbehorende functie uit. Dit maakt HTTP-triggers ideaal voor het bouwen van API's, webhooks en event-gestuurde webapplicaties.

Belangrijkste voordelen van het gebruik van HTTP-triggers:

• Schaalbaarheid: Cloud Functions schalen automatisch om inkomende HTTP-verzoeken af te handelen. U hoeft zich geen zorgen te maken over het inrichten of beheren van servers.
• Kosteneffectiviteit: U betaalt alleen voor de tijd dat uw functie wordt uitgevoerd. Wanneer uw functie inactief is, worden er geen kosten in rekening gebracht.
• Gebruiksgemak: Cloud Functions vereenvoudigt het ontwikkel- en implementatieproces. U kunt zich concentreren op het schrijven van uw functiecode en Google Cloud zorgt voor de infrastructuur.
• Integratie: Met HTTP-triggers kunt u uw Cloud Functions eenvoudig integreren met andere services, zoals webapplicaties, mobiele apps en API's van derden.

Een Cloud Function maken met een HTTP-trigger

Laten we het proces doorlopen van het maken van een eenvoudige Cloud Function met een HTTP-trigger. We maken een functie die reageert met een "Hallo Wereld!"-bericht. Dit voorbeeld kan worden aangepast voor verschillende wereldwijde locaties door simpelweg de uitvoerstring aan te passen.

Vereisten:

• Een Google Cloud Platform (GCP)-account.
• De Google Cloud SDK (gcloud) geïnstalleerd en geconfigureerd.

Stappen:

1. Maak een nieuw project (als je er geen hebt):

   Als u nog geen GCP-project hebt, maak er dan een in de Google Cloud Console.

2. Schakel de Cloud Functions API in:

   Navigeer in de Cloud Console naar de Cloud Functions API en schakel deze in.

3. Maak een functiemap:

   Maak een nieuwe map voor uw Cloud Function. Bijvoorbeeld:

               mkdir hello-http
   cd hello-http
               
   
                 
                   Copy
                 
               
             

4. Schrijf de functiecode:

   Maak een bestand met de naam `main.py` (of `index.js` voor Node.js) met de volgende code:

   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. Maak een vereistenbestand (alleen Python):

   Als u Python gebruikt, maakt u een bestand met de naam `requirements.txt` en voegt u eventuele afhankelijkheden toe die uw functie nodig heeft. Voor dit voorbeeld is het niet strikt noodzakelijk, maar het is een goede gewoonte om er een op te nemen. U kunt het leeg laten als u geen afhankelijkheden hebt.

6. Implementeer de functie:

   Gebruik de opdracht `gcloud functions deploy` om uw functie te implementeren. Vervang `YOUR_FUNCTION_NAME` door de gewenste naam voor uw functie.

   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
                 
               
             

   Uitleg van parameters:

   • `YOUR_FUNCTION_NAME`: De naam die u aan uw Cloud Function wilt geven.
   • `--runtime`: De runtime-omgeving voor uw functie (bijv. `python39`, `nodejs16`).
   • `--trigger-http`: Specificeert dat de functie moet worden geactiveerd door HTTP-verzoeken.
   • `--allow-unauthenticated`: Hiermee kan iedereen de functie aanroepen zonder authenticatie. Waarschuwing: Wees voorzichtig bij het inschakelen hiervan in productieomgevingen! Overweeg om de juiste authenticatie en autorisatie te implementeren.
7. Test de functie:

   Na de implementatie geeft de opdracht `gcloud` de URL van uw functie weer. U kunt het vervolgens testen door een HTTP-verzoek naar die URL te sturen met een tool zoals `curl` of Postman.

               curl YOUR_FUNCTION_URL
               
   
                 
                   Copy
                 
               
             

   U zou het "Hallo Wereld!"-bericht in het antwoord moeten zien. U kunt ook een naam doorgeven als queryparameter:

               curl "YOUR_FUNCTION_URL?name=YourName"
               
   
                 
                   Copy
                 
               
             

   Dit zou "Hallo, YourName!" moeten retourneren.

Inzicht in het HTTP-verzoek en -antwoord

Wanneer een Cloud Function wordt geactiveerd door een HTTP-verzoek, ontvangt deze een object met informatie over het verzoek. Dit object bevat doorgaans:

• Headers: HTTP-headers die met het verzoek zijn verzonden.
• Body: De hoofdtekst van het verzoek (bijv. JSON-gegevens, formuliergegevens).
• Queryparameters: Parameters die in de URL worden doorgegeven.
• Methode: De HTTP-methode (bijv. GET, POST, PUT, DELETE).

Uw functie moet vervolgens een HTTP-antwoord retourneren, dat het volgende omvat:

• Statuscode: De HTTP-statuscode (bijv. 200 OK, 400 Bad Request, 500 Internal Server Error).
• Headers: HTTP-headers die met het antwoord moeten worden verzonden.
• Body: De hoofdtekst van het antwoord (bijv. JSON-gegevens, HTML-inhoud).

Voorbeeld: verschillende HTTP-methoden afhandelen

Hier is een voorbeeld van het afhandelen van verschillende HTTP-methoden in uw Cloud Function:

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
              
            
          

Vergeet niet om de bijgewerkte functie te implementeren met behulp van de opdracht `gcloud functions deploy`.

Uw HTTP-triggers beveiligen

Beveiliging is van het grootste belang bij het werken met HTTP-triggers, vooral bij het omgaan met gevoelige gegevens of kritieke bewerkingen. Hier zijn enkele belangrijke beveiligingsoverwegingen:

Authenticatie en autorisatie

Standaard zijn Cloud Functions die door HTTP worden geactiveerd openbaar toegankelijk als u `--allow-unauthenticated` gebruikt. In de meeste productiescenario's wilt u de toegang beperken tot geautoriseerde gebruikers of services. Google Cloud biedt verschillende opties voor authenticatie en autorisatie:

• Identity-Aware Proxy (IAP): Met IAP kunt u de toegang tot uw Cloud Functions beheren op basis van Google-identiteiten. Het vereist dat gebruikers zich authenticeren met hun Google-accounts voordat ze toegang krijgen tot de functie.
• Service-accounts: U kunt een service-account toewijzen aan uw Cloud Function en deze gebruiken om te authenticeren bij andere Google Cloud-services. Dit is handig om uw functie toegang te geven tot bronnen zoals Cloud Storage of Cloud Datastore.
• Aangepaste authenticatie: U kunt uw eigen authenticatiemechanisme implementeren, zoals JWT (JSON Web Token) of API-sleutels. Dit geeft u de meeste flexibiliteit, maar vereist ook meer ontwikkelingsinspanning.

Invoervalidatie

Valideer altijd de invoergegevens die door uw Cloud Function worden ontvangen om beveiligingsproblemen zoals SQL-injectie of cross-site scripting (XSS) te voorkomen. Gebruik de juiste opschoon- en escaping-technieken om te beschermen tegen kwaadaardige invoer.

HTTPS

Zorg ervoor dat uw Cloud Function alleen toegankelijk is via HTTPS om de communicatie tussen de client en de functie te versleutelen. Google Cloud Functions biedt automatisch HTTPS-eindpunten.

Snelheidsbeperking

Implementeer snelheidsbeperking om misbruik en denial-of-service (DoS)-aanvallen te voorkomen. U kunt services zoals Google Cloud Armor gebruiken om uw Cloud Functions te beschermen tegen overmatig verkeer.

Gebruiksscenario's voor HTTP-triggers

HTTP-triggers zijn veelzijdig en kunnen worden gebruikt in een breed scala aan toepassingen. Hier zijn enkele veelvoorkomende gebruiksscenario's:

• REST API's: Bouw RESTful API's voor uw web- en mobiele applicaties.
• Webhooks: Integreer met services van derden door webhook-gebeurtenissen te ontvangen.
• Formulierverwerking: Verwerk gegevens die via HTML-formulieren zijn verzonden.
• Afbeeldingsgrootte wijzigen: Activeer het aanpassen van de grootte van afbeeldingen wanneer nieuwe afbeeldingen worden geüpload naar Cloud Storage.
• Gegevenstransformatie: Transformeer gegevens van het ene formaat naar het andere.
• Slack-bots: Maak interactieve Slack-bots.
• Aangepaste webapplicaties: Serveer dynamische inhoud voor kleine webapplicaties of microservices.

Voorbeelden uit verschillende industrieën

• E-commerce (Wereldwijd): Een HTTP-trigger kan worden gebruikt om betalingen van verschillende betalingsgateways wereldwijd te verwerken, transacties te valideren en orderstatussen in realtime bij te werken. De functie kan geolocatie-informatie van het verzoek gebruiken om de juiste belastingen en verzendkosten toe te passen op basis van de locatie van de gebruiker.
• Financiën (Internationaal bankieren): HTTP-triggers kunnen veilige geldoverboekingen tussen verschillende bankrekeningen wereldwijd faciliteren, valutaconversies afhandelen en voldoen aan internationale bankvoorschriften. Authenticatie is hier cruciaal, mogelijk met multi-factor authenticatie via sms of authenticator-apps.
• Gezondheidszorg (Telegeneeskunde): Een HTTP-trigger kan afspraakverzoeken van patiënten over de hele wereld afhandelen, coördineren met verschillende tijdzones en de beschikbaarheid van artsen beheren. Het kan ook worden geïntegreerd met vertaaldiensten om meertalige ondersteuning te bieden. Gegevensprivacy en naleving van voorschriften zoals HIPAA (in de VS) of GDPR (in Europa) zijn van het grootste belang.
• Onderwijs (Online leerplatforms): HTTP-triggers kunnen worden gebruikt om opdrachten automatisch te beoordelen en directe feedback te geven aan studenten, ongeacht hun locatie. Ze kunnen ook gepersonaliseerde leeraanbevelingen activeren op basis van de prestaties van studenten.
• Logistiek (Wereldwijde verzending): HTTP-triggers kunnen worden gebruikt om zendingen in realtime te volgen en klanten wereldwijd updates te geven over de locatie van het pakket en de geschatte levertijden. Integraties met verschillende transporteurs via hun API's via HTTP-triggers zijn gebruikelijk.

Geavanceerde technieken

Omgevingsvariabelen gebruiken

Met omgevingsvariabelen kunt u uw Cloud Function configureren zonder gevoelige informatie of configuratiewaarden in uw code te hardcoderen. U kunt omgevingsvariabelen instellen met de opdracht `gcloud functions deploy` of in de Google Cloud Console.

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

              
                Copy
              
            
          

In uw code hebt u toegang tot omgevingsvariabelen met behulp van het `os.environ`-woordenboek (Python) of het `process.env`-object (Node.js).

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
              
            
          

Asynchrone taken afhandelen

Voor langdurige of rekenintensieve taken kunt u het beste asynchrone verwerking gebruiken om te voorkomen dat het HTTP-verzoek wordt geblokkeerd. U kunt services zoals Google Cloud Tasks of Cloud Pub/Sub gebruiken om deze taken naar afzonderlijke wachtrijen te verplaatsen.

Foutafhandeling en logging

Implementeer robuuste foutafhandeling en logging in uw Cloud Functions om problemen snel te identificeren en op te lossen. Gebruik Google Cloud Logging om logboeken van uw functies te verzamelen en hun prestaties te bewaken.

Best practices

• Houd functies klein en gefocust: Elke functie moet een enkel, goed gedefinieerd doel hebben.
• Gebruik afhankelijkheidsbeheer: Gebruik pakketbeheerders zoals `pip` (Python) of `npm` (Node.js) om uw afhankelijkheden te beheren.
• Test uw functies grondig: Schrijf unit-tests en integratietests om ervoor te zorgen dat uw functies correct werken.
• Bewaak de functieprestaties: Gebruik Google Cloud Monitoring om de uitvoeringstijd van functies, het geheugengebruik en foutpercentages bij te houden.
• Optimaliseer code voor koude starts: Minimaliseer de tijd die uw functie nodig heeft om op te starten (koude start). Dit kan worden bereikt door afhankelijkheden te verminderen, code te optimaliseren en provisioned concurrency te gebruiken (indien beschikbaar).
• Overweeg de functielocatie: Implementeer uw functies in een regio die geografisch dicht bij uw gebruikers ligt om de latentie te minimaliseren. Voor een wereldwijd publiek kunt u overwegen om in meerdere regio's te implementeren.

Veelvoorkomende problemen oplossen

• Functie kan niet worden geïmplementeerd: Controleer op syntaxisfouten in uw code, zorg ervoor dat u de benodigde machtigingen hebt en controleer of u een ondersteunde runtime-omgeving gebruikt.
• Functie retourneert een 500-fout: Controleer de functielogboeken in Google Cloud Logging op foutmeldingen. Veelvoorkomende oorzaken zijn niet-afgehandelde uitzonderingen, ontbrekende afhankelijkheden of onjuiste configuratie.
• Functie heeft een time-out: Verhoog de time-outwaarde van de functie in de Google Cloud Console of met behulp van de opdracht `gcloud functions deploy`. Optimaliseer ook uw code om de uitvoeringstijd te verkorten.
• Functie wordt niet geactiveerd: Controleer of de trigger correct is geconfigureerd en of het HTTP-verzoek naar de juiste URL wordt verzonden.

Conclusie

Google Cloud Functions met HTTP-triggers bieden een krachtige en flexibele manier om serverloze applicaties te bouwen. Door de concepten en technieken te begrijpen die in deze handleiding worden besproken, kunt u de kracht van Cloud Functions benutten om schaalbare, kosteneffectieve en event-gestuurde oplossingen te creëren voor een wereldwijd publiek. Omarm de serverloze revolutie en ontsluit het volledige potentieel van uw cloudapplicaties!