M

MLOG

Nederlands

Ontgrendel de kracht van serverloos computergebruik met Google Cloud Functions. Deze handleiding verkent HTTP-triggers en biedt ontwikkelaars wereldwijd de kennis om schaalbare, event-gestuurde applicaties te bouwen.

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:

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:

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
  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}!'

    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}!`);
};
  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

    Node.js:

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

    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

    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"

    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:

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

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

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;
  }
};

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:

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:

Voorbeelden uit verschillende industrieën

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

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}'

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}`);
};

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

Veelvoorkomende problemen oplossen

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!