M

MLOG

Svenska

Lås upp kraften i serverlös databehandling med Google Cloud Functions. Denna guide utforskar HTTP-triggers och ger utvecklare världen över kunskapen att bygga skalbara, händelsestyrda applikationer.

Google Cloud Functions: En Omfattande Guide till HTTP-Triggers

Google Cloud Functions (GCF) är en serverlös exekveringsmiljö som låter dig bygga och ansluta molntjänster. Med Cloud Functions skriver du enkla, enskilda funktioner som är kopplade till händelser som skickas från din molninfrastruktur och dina tjänster. Din funktion körs när den händelse du bevakar inträffar. Denna metod gör att du kan utveckla händelsestyrda applikationer utan att hantera servrar eller körtider.

Ett av de vanligaste sätten att utlösa en Cloud Function är via en HTTP-begäran. Denna guide kommer att fördjupa sig i världen av HTTP-triggers i Google Cloud Functions och ge dig kunskapen att bygga kraftfulla, skalbara och kostnadseffektiva applikationer.

Vad är HTTP-Triggers?

En HTTP-trigger låter dig köra din Cloud Function som svar på en HTTP-begäran. I grund och botten, när en HTTP-begäran skickas till en specifik URL, kommer Google Cloud Functions automatiskt att köra den associerade funktionen. Detta gör HTTP-triggers idealiska för att bygga API:er, webhooks och händelsestyrda webbapplikationer.

Viktiga Fördelar med att Använda HTTP-Triggers:

Skapa en Cloud Function med en HTTP-Trigger

Låt oss gå igenom processen att skapa en enkel Cloud Function med en HTTP-trigger. Vi kommer att skapa en funktion som svarar med ett "Hello, World!"-meddelande. Detta exempel kan anpassas för olika globala platser genom att helt enkelt ändra utdatasträngen.

Förutsättningar:

Steg:

  1. Skapa ett nytt projekt (om du inte har något):

    Om du inte redan har ett GCP-projekt, skapa ett i Google Cloud Console.

  2. Aktivera Cloud Functions API:

    I Cloud Console, navigera till Cloud Functions API och aktivera det.

  3. Skapa en funktionskatalog:

    Skapa en ny katalog för din Cloud Function. Till exempel:

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

    Skapa en fil med namnet `main.py` (eller `index.js` för Node.js) med följande kod:

    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. Skapa en kravfil (endast Python):

    Om du använder Python, skapa en fil med namnet `requirements.txt` och lägg till eventuella beroenden som din funktion behöver. För detta exempel är det inte strikt nödvändigt, men det är god praxis att inkludera en. Du kan lämna den tom om du inte har några beroenden.

  6. Distribuera funktionen:

    Använd kommandot `gcloud functions deploy` för att distribuera din funktion. Ersätt `YOUR_FUNCTION_NAME` med önskat namn för 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

    Förklaring av parametrar:

    • `YOUR_FUNCTION_NAME`: Det namn du vill ge din Cloud Function.
    • `--runtime`: Körtidsmiljön för din funktion (t.ex. `python39`, `nodejs16`).
    • `--trigger-http`: Anger att funktionen ska utlösas av HTTP-begäranden.
    • `--allow-unauthenticated`: Tillåter vem som helst att anropa funktionen utan autentisering. Varning: Var försiktig när du aktiverar detta i produktionsmiljöer! Överväg att implementera korrekt autentisering och auktorisering.
  7. Testa funktionen:

    Efter driftsättning kommer kommandot `gcloud` att mata ut URL:en för din funktion. Du kan sedan testa den genom att skicka en HTTP-begäran till den URL:en med ett verktyg som `curl` eller Postman.

    curl YOUR_FUNCTION_URL

    Du bör se meddelandet "Hello, World!" i svaret. Du kan också skicka ett namn som en frågeparameter:

    curl "YOUR_FUNCTION_URL?name=YourName"

    Detta bör returnera "Hello, YourName!"

Förstå HTTP-Begäran och Svar

När en Cloud Function utlöses av en HTTP-begäran får den ett objekt som innehåller information om begäran. Detta objekt innehåller vanligtvis:

Din funktion ska då returnera ett HTTP-svar, som innehåller:

Exempel: Hantera Olika HTTP-Metoder

Här är ett exempel på hur du hanterar olika 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;
  }
};

Kom ihåg att distribuera den uppdaterade funktionen med kommandot `gcloud functions deploy`.

Säkra Dina HTTP-Triggers

Säkerhet är av största vikt när du arbetar med HTTP-triggers, särskilt när du hanterar känslig data eller kritiska operationer. Här är några viktiga säkerhetsöverväganden:

Autentisering och Auktorisering

Som standard är Cloud Functions som utlöses av HTTP publikt tillgängliga om du använder `--allow-unauthenticated`. I de flesta produktionsscenarier vill du begränsa åtkomsten till behöriga användare eller tjänster. Google Cloud tillhandahåller flera alternativ för autentisering och auktorisering:

Indatavalidering

Validera alltid indata som tas emot av din Cloud Function för att förhindra säkerhetsproblem som SQL-injection eller cross-site scripting (XSS). Använd lämpliga sanerings- och escape-tekniker för att skydda mot skadlig indata.

HTTPS

Se till att din Cloud Function endast är tillgänglig via HTTPS för att kryptera kommunikationen mellan klienten och funktionen. Google Cloud Functions tillhandahåller automatiskt HTTPS-slutpunkter.

Begränsning av hastighet

Implementera hastighetsbegränsning för att förhindra missbruk och denial-of-service (DoS)-attacker. Du kan använda tjänster som Google Cloud Armor för att skydda dina Cloud Functions från överdriven trafik.

Användningsfall för HTTP-Triggers

HTTP-triggers är mångsidiga och kan användas i ett brett utbud av applikationer. Här är några vanliga användningsfall:

Exempel över Olika Industrier

Avancerade Tekniker

Använda Miljövariabler

Med miljövariabler kan du konfigurera din Cloud Function utan att hårdkoda känslig information eller konfigurationsvärden i din kod. Du kan ställa in miljövariabler med kommandot `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 kod kan du komma åt miljövariabler med hjälp av `os.environ`-ordboken (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}`);
};

Hantera Asynkrona Uppgifter

För långvariga eller beräkningsintensiva uppgifter är det bäst att använda asynkron bearbetning för att undvika att blockera HTTP-begäran. Du kan använda tjänster som Google Cloud Tasks eller Cloud Pub/Sub för att flytta dessa uppgifter till separata köer.

Felhantering och Loggning

Implementera robust felhantering och loggning i dina Cloud Functions för att snabbt identifiera och lösa problem. Använd Google Cloud Logging för att samla in loggar från dina funktioner och övervaka deras prestanda.

Bästa Praxis

Felsökning av Vanliga Problem

Slutsats

Google Cloud Functions med HTTP-triggers ger ett kraftfullt och flexibelt sätt att bygga serverlösa applikationer. Genom att förstå de koncept och tekniker som diskuteras i den här guiden kan du utnyttja kraften i Cloud Functions för att skapa skalbara, kostnadseffektiva och händelsestyrda lösningar för en global publik. Omfamna den serverlösa revolutionen och lås upp den fulla potentialen i dina molnapplikationer!