M

MLOG

Dansk

Udforsk Google Cloud Functions' HTTP-triggere for at bygge skalerbare, hændelsesdrevne applikationer. Denne guide giver udviklere viden til serverløs computing.

Google Cloud Functions: En omfattende guide til HTTP-triggere

Google Cloud Functions (GCF) er et serverløst eksekveringsmiljø, der lader dig bygge og forbinde cloud-tjenester. Med Cloud Functions skriver du enkle funktioner med ét formål, der er knyttet til hændelser, der udsendes fra din cloud-infrastruktur og -tjenester. Din funktion eksekveres, når den hændelse, du overvåger, opstår. Denne tilgang giver dig mulighed for at udvikle hændelsesdrevne applikationer uden at skulle administrere servere eller kørselsmiljøer.

En af de mest almindelige måder at udløse en Cloud Function på er via en HTTP-anmodning. Denne guide vil dykke ned i verden af HTTP-triggere i Google Cloud Functions og give dig viden til at bygge kraftfulde, skalerbare og omkostningseffektive applikationer.

Hvad er HTTP-triggere?

En HTTP-trigger gør det muligt at eksekvere din Cloud Function som reaktion på en HTTP-anmodning. Grundlæggende vil Google Cloud Functions automatisk eksekvere den tilknyttede funktion, når en HTTP-anmodning sendes til en specifik URL. Dette gør HTTP-triggere ideelle til at bygge API'er, webhooks og hændelsesdrevne webapplikationer.

Vigtige fordele ved at bruge HTTP-triggere:

Oprettelse af en Cloud Function med en HTTP-trigger

Lad os gennemgå processen med at oprette en simpel Cloud Function med en HTTP-trigger. Vi vil oprette en funktion, der svarer med en "Hello, World!"-besked. Dette eksempel kan tilpasses forskellige globale lokationer ved blot at ændre outputstrengen.

Forudsætninger:

Trin:

  1. Opret et nyt projekt (hvis du ikke har et):

    Hvis du ikke allerede har et GCP-projekt, skal du oprette et i Google Cloud Console.

  2. Aktiver Cloud Functions API'et:

    I Cloud Console skal du navigere til Cloud Functions API'et og aktivere det.

  3. Opret en funktionsmappe:

    Opret en ny mappe til din Cloud Function. For eksempel:

    mkdir hello-http
cd hello-http
  4. Skriv funktionskoden:

    Opret en fil med navnet `main.py` (eller `index.js` for Node.js) med følgende kode:

    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. Opret en requirements-fil (kun Python):

    Hvis du bruger Python, skal du oprette en fil med navnet `requirements.txt` og tilføje eventuelle afhængigheder, din funktion har brug for. I dette eksempel er det ikke strengt nødvendigt, men det er god praksis at inkludere en. Du kan lade den være tom, hvis du ikke har nogen afhængigheder.

  6. Implementer funktionen:

    Brug kommandoen `gcloud functions deploy` til at implementere din funktion. Erstat `YOUR_FUNCTION_NAME` med det ønskede navn til din funktion.

    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

    Forklaring af parametre:

    • `YOUR_FUNCTION_NAME`: Navnet du ønsker at give din Cloud Function.
    • `--runtime`: Kørselsmiljøet for din funktion (f.eks. `python39`, `nodejs16`).
    • `--trigger-http`: Angiver at funktionen skal udløses af HTTP-anmodninger.
    • `--allow-unauthenticated`: Tillader enhver at kalde funktionen uden godkendelse. Advarsel: Udvis forsigtighed, når dette aktiveres i produktionsmiljøer! Overvej at implementere korrekt godkendelse og autorisation.
  7. Test funktionen:

    Efter implementering vil `gcloud`-kommandoen udskrive URL'en til din funktion. Du kan derefter teste den ved at sende en HTTP-anmodning til den URL ved hjælp af et værktøj som `curl` eller Postman.

    curl YOUR_FUNCTION_URL

    Du skulle gerne se "Hello, World!"-beskeden i svaret. Du kan også sende et navn som en forespørgselsparameter:

    curl \"YOUR_FUNCTION_URL?name=YourName\"

    Dette skulle returnere "Hello, YourName!"

Forståelse af HTTP-anmodningen og -svaret

Når en Cloud Function udløses af en HTTP-anmodning, modtager den et objekt, der indeholder information om anmodningen. Dette objekt inkluderer typisk:

Din funktion skal derefter returnere et HTTP-svar, som inkluderer:

Eksempel: Håndtering af forskellige HTTP-metoder

Her er et eksempel på, hvordan du håndterer forskellige HTTP-metoder i din 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;
  }
};

Husk at implementere den opdaterede funktion ved hjælp af `gcloud functions deploy`-kommandoen.

Sikring af dine HTTP-triggere

Sikkerhed er altafgørende, når du arbejder med HTTP-triggere, især når du håndterer følsomme data eller kritiske operationer. Her er nogle vigtige sikkerhedshensyn:

Godkendelse og autorisation

Som standard er Cloud Functions udløst af HTTP offentligt tilgængelige, hvis du bruger `--allow-unauthenticated`. I de fleste produktionsscenarier vil du begrænse adgangen til autoriserede brugere eller tjenester. Google Cloud tilbyder flere muligheder for godkendelse og autorisation:

Inputvalidering

Valider altid inputdata modtaget af din Cloud Function for at forhindre sikkerhedsbrister som SQL-injektion eller cross-site scripting (XSS). Brug passende sanering og escaping-teknikker til at beskytte mod skadeligt input.

HTTPS

Sørg for, at din Cloud Function kun er tilgængelig over HTTPS for at kryptere kommunikation mellem klienten og funktionen. Google Cloud Functions leverer automatisk HTTPS-endpoints.

Hastighedsbegrænsning

Implementer hastighedsbegrænsning for at forhindre misbrug og denial-of-service (DoS)-angreb. Du kan bruge tjenester som Google Cloud Armor til at beskytte dine Cloud Functions mod overdreven trafik.

Anvendelsestilfælde for HTTP-triggere

HTTP-triggere er alsidige og kan bruges i en bred vifte af applikationer. Her er nogle almindelige anvendelsestilfælde:

Eksempler på tværs af forskellige brancher

Avancerede teknikker

Brug af miljøvariabler

Miljøvariabler giver dig mulighed for at konfigurere din Cloud Function uden at hardcode følsomme informationer eller konfigurationsværdier i din kode. Du kan indstille miljøvariabler ved hjælp af kommandoen `gcloud functions deploy` eller i 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

I din kode kan du få adgang til miljøvariabler ved hjælp af `os.environ`-ordbogen (Python) eller `process.env`-objektet (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}`);
};

Håndtering af asynkrone opgaver

For langvarige eller beregningstunge opgaver er det bedst at bruge asynkron behandling for at undgå at blokere HTTP-anmodningen. Du kan bruge tjenester som Google Cloud Tasks eller Cloud Pub/Sub til at aflaste disse opgaver til separate køer.

Fejlhåndtering og logning

Implementer robust fejlhåndtering og logning i dine Cloud Functions for hurtigt at identificere og løse problemer. Brug Google Cloud Logging til at indsamle logs fra dine funktioner og overvåge deres ydeevne.

Bedste praksis

Fejlfinding af almindelige problemer

Konklusion

Google Cloud Functions med HTTP-triggere giver en kraftfuld og fleksibel måde at bygge serverløse applikationer på. Ved at forstå de koncepter og teknikker, der er diskuteret i denne guide, kan du udnytte kraften i Cloud Functions til at skabe skalerbare, omkostningseffektive og hændelsesdrevne løsninger til et globalt publikum. Omfavn den serverløse revolution og udløs det fulde potentiale i dine cloud-applikationer!