M

MLOG

Norsk

Lås opp kraften i serverløs databehandling med Google Cloud Functions. Denne guiden utforsker HTTP-triggere, og gir utviklere globalt kunnskap til å bygge skalerbare, hendelsesdrevne applikasjoner.

Google Cloud Functions: En omfattende guide til HTTP-triggere

Google Cloud Functions (GCF) er et serverløst utførelsesmiljø som lar deg bygge og koble sammen skytjenester. Med Cloud Functions skriver du enkle, enkeltformålsfunksjoner som er knyttet til hendelser som sendes fra din skyinfrastruktur og tjenester. Funksjonen din blir utført når hendelsen du observerer, oppstår. Denne tilnærmingen lar deg utvikle hendelsesdrevne applikasjoner uten å administrere servere eller kjøretidsmiljøer.

En av de vanligste måtene å trigge en Cloud Function på er via en HTTP-forespørsel. Denne guiden vil dykke ned i verden av HTTP-triggere i Google Cloud Functions, og gi deg kunnskapen til å bygge kraftige, skalerbare og kostnadseffektive applikasjoner.

Hva er HTTP-triggere?

En HTTP-trigger lar deg utføre din Cloud Function som respons på en HTTP-forespørsel. I hovedsak, når en HTTP-forespørsel sendes til en spesifikk URL, vil Google Cloud Functions automatisk utføre den tilhørende funksjonen. Dette gjør HTTP-triggere ideelle for å bygge API-er, webhooks og hendelsesdrevne webapplikasjoner.

Viktige fordeler med å bruke HTTP-triggere:

Opprette en Cloud Function med en HTTP-trigger

La oss gå gjennom prosessen med å opprette en enkel Cloud Function med en HTTP-trigger. Vi vil lage en funksjon som svarer med en "Hei, Verden!"-melding. Dette eksemplet kan tilpasses for ulike globale lokasjoner ved å ganske enkelt endre utdatastrengen.

Forutsetninger:

Steg:

  1. Opprett et nytt prosjekt (hvis du ikke har et):

    Hvis du ikke allerede har et GCP-prosjekt, opprett et i Google Cloud Console.

  2. Aktiver Cloud Functions API:

    Naviger til Cloud Functions API i Cloud Console og aktiver det.

  3. Opprett en funksjonskatalog:

    Opprett en ny katalog for din Cloud Function. For eksempel:

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

    Opprett en fil kalt `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): Request-objektet.
        
    Returns:
        Responsteksten, eller et hvilket som helst sett med verdier som kan gjøres om til et
        Response-objekt ved bruk av `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. Opprett en kravfil (kun Python):

    Hvis du bruker Python, opprett en fil kalt `requirements.txt` og legg til eventuelle avhengigheter funksjonen din trenger. For dette eksemplet er det ikke strengt tatt nødvendig, men det er god praksis å inkludere en. Du kan la den være tom hvis du ikke har noen avhengigheter.

  6. Rull ut funksjonen:

    Bruk kommandoen `gcloud functions deploy` for å rulle ut funksjonen din. Erstatt `YOUR_FUNCTION_NAME` med ønsket navn på funksjonen din.

    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 av parametere:

    • `YOUR_FUNCTION_NAME`: Navnet du vil gi Cloud Function.
    • `--runtime`: Kjøretidsmiljøet for funksjonen din (f.eks. `python39`, `nodejs16`).
    • `--trigger-http`: Spesifiserer at funksjonen skal trigges av HTTP-forespørsler.
    • `--allow-unauthenticated`: Tillater at hvem som helst kan kalle funksjonen uten autentisering. Advarsel: Vær forsiktig med å aktivere dette i produksjonsmiljøer! Vurder å implementere riktig autentisering og autorisasjon.
  7. Test funksjonen:

    Etter utrulling vil `gcloud`-kommandoen gi URL-en til funksjonen din. Du kan deretter teste den ved å sende en HTTP-forespørsel til den URL-en ved hjelp av et verktøy som `curl` eller Postman.

    curl YOUR_FUNCTION_URL

    Du bør se "Hei, Verden!"-meldingen i responsen. Du kan også sende et navn som en spørringsparameter:

    curl "YOUR_FUNCTION_URL?name=DittNavn"

    Dette bør returnere "Hello, DittNavn!"

Forstå HTTP-forespørselen og -responsen

Når en Cloud Function trigges av en HTTP-forespørsel, mottar den et objekt som inneholder informasjon om forespørselen. Dette objektet inkluderer vanligvis:

Funksjonen din bør deretter returnere en HTTP-respons, som inkluderer:

Eksempel: Håndtere forskjellige HTTP-metoder

Her er et eksempel på hvordan du kan håndtere forskjellige HTTP-metoder i din Cloud Function:

Python (main.py):

from flask import escape

def http_method(request):
    """Svarer på enhver HTTP-forespørsel.
    Args:
        request (flask.Request): HTTP-forespørselsobjekt.
    Returns:
        Responsteksten eller et hvilket som helst sett med verdier som kan gjøres om til et
        Response-objekt ved bruk av
        `make_response``.
    """
    if request.method == 'GET':
        return 'Dette er en GET-forespørsel!'
    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'Dette er en POST-forespørsel med melding: {message}'
        else:
            return 'Dette er en POST-forespørsel uten melding.'
    else:
        return 'Ugyldig HTTP-metode.', 405

Node.js (index.js:

exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('Dette er en GET-forespørsel!');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`Dette er en POST-forespørsel med melding: ${message}`);
      } else {
        res.status(200).send('Dette er en POST-forespørsel uten melding.');
      }
      break;
    default:
      res.status(405).send('Ugyldig HTTP-metode!');
      break;
  }
};

Husk å rulle ut den oppdaterte funksjonen ved hjelp av `gcloud functions deploy`-kommandoen.

Sikring av HTTP-triggerne dine

Sikkerhet er avgjørende når du arbeider med HTTP-triggere, spesielt når du håndterer sensitiv data eller kritiske operasjoner. Her er noen viktige sikkerhetshensyn:

Autentisering og autorisasjon

Som standard er Cloud Functions som trigges av HTTP offentlig tilgjengelige hvis du bruker `--allow-unauthenticated`. I de fleste produksjonsscenarier vil du begrense tilgang til autoriserte brukere eller tjenester. Google Cloud tilbyr flere alternativer for autentisering og autorisasjon:

Inndatavalidering

Valider alltid inndataene som mottas av din Cloud Function for å forhindre sikkerhetssårbarheter som SQL-injeksjon eller cross-site scripting (XSS). Bruk passende sanitiserings- og unntaksteknikker for å beskytte mot ondsinnet inndata.

HTTPS

Sørg for at Cloud Function kun er tilgjengelig via HTTPS for å kryptere kommunikasjonen mellom klienten og funksjonen. Google Cloud Functions tilbyr automatisk HTTPS-endepunkter.

Hastighetsbegrensning

Implementer hastighetsbegrensning for å forhindre misbruk og tjenestenektangrep (DoS). Du kan bruke tjenester som Google Cloud Armor for å beskytte dine Cloud Functions mot overdreven trafikk.

Brukstilfeller for HTTP-triggere

HTTP-triggere er allsidige og kan brukes i et bredt spekter av applikasjoner. Her er noen vanlige brukstilfeller:

Eksempler fra forskjellige bransjer

Avanserte teknikker

Bruk av miljøvariabler

Miljøvariabler lar deg konfigurere Cloud Function uten å hardkode sensitiv informasjon eller konfigurasjonsverdier i koden din. Du kan sette miljøvariabler ved bruk av `gcloud functions deploy`-kommandoen eller i Google Cloud Console.

gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=DIN_API_NØKKEL,DATABASE_URL=DIN_DATABASE_URL

I koden din kan du få tilgang til miljøvariabler ved bruk av `os.environ`-ordlisten (Python) eller `process.env`-objektet (Node.js).

Python:

import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Bruk API-nøkkelen i funksjonen din
    return f'API Nøkkel: {api_key}'

Node.js:

exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Bruk API-nøkkelen i funksjonen din
  res.status(200).send(`API Nøkkel: ${apiKey}`);
};

Håndtere asynkrone oppgaver

For langvarige eller beregningsmessig intensive oppgaver er det best å bruke asynkron behandling for å unngå å blokkere HTTP-forespørselen. Du kan bruke tjenester som Google Cloud Tasks eller Cloud Pub/Sub til å laste av disse oppgavene til separate køer.

Feilhåndtering og logging

Implementer robust feilhåndtering og logging i dine Cloud Functions for å identifisere og løse problemer raskt. Bruk Google Cloud Logging for å samle logger fra funksjonene dine og overvåke ytelsen deres.

Beste praksis

Feilsøking av vanlige problemer

Konklusjon

Google Cloud Functions med HTTP-triggere gir en kraftig og fleksibel måte å bygge serverløse applikasjoner på. Ved å forstå konseptene og teknikkene som er diskutert i denne guiden, kan du utnytte kraften i Cloud Functions til å skape skalerbare, kostnadseffektive og hendelsesdrevne løsninger for et globalt publikum. Omfavn den serverløse revolusjonen og lås opp det fulle potensialet i dine skyapplikasjoner!

Google Cloud Functions: En omfattende guide til HTTP-triggere | MLOG