M

MLOG

Română

Deblocați puterea calculului serverless cu Google Cloud Functions. Acest ghid explorează declanșatoarele HTTP, oferind dezvoltatorilor din întreaga lume cunoștințe pentru a construi aplicații scalabile, bazate pe evenimente.

Google Cloud Functions: Un ghid cuprinzător pentru declanșatoare HTTP

Google Cloud Functions (GCF) este un mediu de execuție serverless care vă permite să construiți și să conectați servicii cloud. Cu Cloud Functions, scrieți funcții simple, cu scop unic, care sunt atașate evenimentelor emise de infrastructura și serviciile cloud. Funcția dvs. este executată atunci când evenimentul pe care îl urmăriți apare. Această abordare vă permite să dezvoltați aplicații bazate pe evenimente fără a gestiona servere sau runtime-uri.

Una dintre cele mai comune modalități de a declanșa o funcție Cloud este printr-o cerere HTTP. Acest ghid va aprofunda lumea declanșatoarelor HTTP în Google Cloud Functions, oferindu-vă cunoștințele necesare pentru a construi aplicații puternice, scalabile și eficiente din punct de vedere al costurilor.

Ce sunt declanșatoarele HTTP?

Un declanșator HTTP vă permite să executați funcția dvs. Cloud ca răspuns la o cerere HTTP. În esență, atunci când o cerere HTTP este trimisă la un URL specific, Google Cloud Functions va executa automat funcția asociată. Acest lucru face ca declanșatoarele HTTP să fie ideale pentru construirea de API-uri, webhook-uri și aplicații web bazate pe evenimente.

Beneficii cheie ale utilizării declanșatoarelor HTTP:

Crearea unei funcții Cloud cu un declanșator HTTP

Să parcurgem procesul de creare a unei funcții Cloud simple cu un declanșator HTTP. Vom crea o funcție care răspunde cu mesajul „Hello, World!”. Acest exemplu poate fi adaptat pentru diverse locale globale, modificând pur și simplu șirul de ieșire.

Precondiții:

Pași:

  1. Creați un proiect nou (dacă nu aveți unul):

    Dacă nu aveți deja un proiect GCP, creați unul în Google Cloud Console.

  2. Activați API-ul Cloud Functions:

    În Cloud Console, navigați la API-ul Cloud Functions și activați-l.

  3. Creați un director pentru funcție:

    Creați un director nou pentru funcția dvs. Cloud. De exemplu:

    mkdir hello-http
cd hello-http
  4. Scrieți codul funcției:

    Creați un fișier numit `main.py` (sau `index.js` pentru Node.js) cu următorul cod:

    Python (main.py):

    def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): Obiectul cererii.
        <https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request>
    Returns:
        Textul răspunsului sau orice set de valori care pot fi transformate într-un
        obiect Response utilizând `make_response`
        <https://flask.palletsprojects.com/en/1.1.x/api/#flask.Flask.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. Creați un fișier de cerințe (doar Python):

    Dacă utilizați Python, creați un fișier numit `requirements.txt` și adăugați orice dependențe de care funcția dvs. are nevoie. Pentru acest exemplu, nu este strict necesar, dar este o practică bună să includeți unul. Puteți să-l lăsați gol dacă nu aveți dependențe.

  6. Implementați funcția:

    Utilizați comanda `gcloud functions deploy` pentru a implementa funcția dvs. Înlocuiți `YOUR_FUNCTION_NAME` cu numele dorit pentru funcția dvs.

    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

    Explicația parametrilor:

    • `YOUR_FUNCTION_NAME`: Numele pe care doriți să-l dați funcției dvs. Cloud.
    • `--runtime`: Mediul de execuție pentru funcția dvs. (de exemplu, `python39`, `nodejs16`).
    • `--trigger-http`: Specifică faptul că funcția trebuie declanșată de cereri HTTP.
    • `--allow-unauthenticated`: Permite oricui să invoce funcția fără autentificare. Atenție: Aveți grijă când activați acest lucru în medii de producție! Luați în considerare implementarea autentificării și autorizării corespunzătoare.
  7. Testați funcția:

    După implementare, comanda `gcloud` va afișa URL-ul funcției dvs. Apoi îl puteți testa trimițând o cerere HTTP la acel URL utilizând un instrument precum `curl` sau Postman.

    curl YOUR_FUNCTION_URL

    Ar trebui să vedeți mesajul „Hello, World!” în răspuns. Puteți, de asemenea, să transmiteți un nume ca parametru de interogare:

    curl "YOUR_FUNCTION_URL?name=YourName"

    Acest lucru ar trebui să returneze „Hello, YourName!”

Înțelegerea cererii și răspunsului HTTP

Când o funcție Cloud este declanșată de o cerere HTTP, ea primește un obiect care conține informații despre cerere. Acest obiect include, în general:

Funcția dvs. ar trebui apoi să returneze un răspuns HTTP, care include:

Exemplu: Gestionarea diferitelor metode HTTP

Iată un exemplu despre cum să gestionați diferite metode HTTP în funcția dvs. Cloud:

Python (main.py):

from flask import escape

def http_method(request):
    """Răspunde la orice cerere HTTP.
    Args:
        request (flask.Request): Obiectul cererii HTTP.
    Returns:
        Textul răspunsului sau orice set de valori care pot fi transformate într-un
        obiect Response utilizând
        `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;
  }
};

Nu uitați să implementați funcția actualizată utilizând comanda `gcloud functions deploy`.

Securizarea declanșatoarelor dvs. HTTP

Securitatea este primordială atunci când lucrați cu declanșatoare HTTP, în special atunci când manipulați date sensibile sau operațiuni critice. Iată câteva considerații cheie privind securitatea:

Autentificare și autorizare

În mod implicit, funcțiile Cloud declanșate prin HTTP sunt accesibile public dacă utilizați `--allow-unauthenticated`. În majoritatea scenariilor de producție, veți dori să restricționați accesul la utilizatorii sau serviciile autorizate. Google Cloud oferă mai multe opțiuni pentru autentificare și autorizare:

Validarea intrărilor

Validați întotdeauna datele de intrare primite de funcția dvs. Cloud pentru a preveni vulnerabilitățile de securitate, cum ar fi SQL injection sau cross-site scripting (XSS). Utilizați tehnici adecvate de sanitizare și escape pentru a vă proteja împotriva intrărilor malițioase.

HTTPS

Asigurați-vă că funcția dvs. Cloud este accesibilă doar prin HTTPS pentru a cripta comunicarea dintre client și funcție. Google Cloud Functions oferă automat puncte de acces HTTPS.

Limitarea ratei

Implementați limitarea ratei pentru a preveni abuzurile și atacurile de tip denial-of-service (DoS). Puteți utiliza servicii precum Google Cloud Armor pentru a vă proteja funcțiile Cloud de traficul excesiv.

Cazuri de utilizare pentru declanșatoare HTTP

Declanșatoarele HTTP sunt versatile și pot fi utilizate într-o gamă largă de aplicații. Iată câteva cazuri de utilizare comune:

Exemple din diverse industrii

Tehnici avansate

Utilizarea variabilelor de mediu

Variabilele de mediu vă permit să configurați funcția dvs. Cloud fără a încorpora informații sensibile sau valori de configurare în codul dvs. Puteți seta variabile de mediu utilizând comanda `gcloud functions deploy` sau în 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

În codul dvs., puteți accesa variabilele de mediu utilizând dicționarul `os.environ` (Python) sau obiectul `process.env` (Node.js).

Python:

import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Utilizați cheia API în funcția dvs.
    return f'API Key: {api_key}'

Node.js:

exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Utilizați cheia API în funcția dvs.
  res.status(200).send(`API Key: ${apiKey}`);
};

Gestionarea sarcinilor asincrone

Pentru sarcini de lungă durată sau intensive din punct de vedere computațional, este mai bine să utilizați procesarea asincronă pentru a evita blocarea cererii HTTP. Puteți utiliza servicii precum Google Cloud Tasks sau Cloud Pub/Sub pentru a descărca aceste sarcini în cozi separate.

Gestionarea erorilor și înregistrarea

Implementați gestionarea robustă a erorilor și înregistrarea în funcțiile dvs. Cloud pentru a identifica și rezolva rapid problemele. Utilizați Google Cloud Logging pentru a colecta jurnalele de la funcțiile dvs. și pentru a le monitoriza performanța.

Cele mai bune practici

Depanarea problemelor comune

Concluzie

Google Cloud Functions cu declanșatoare HTTP oferă o modalitate puternică și flexibilă de a construi aplicații serverless. Prin înțelegerea conceptelor și tehnicilor discutate în acest ghid, puteți valorifica puterea Cloud Functions pentru a crea soluții scalabile, eficiente din punct de vedere al costurilor și bazate pe evenimente pentru un public global. Îmbrățișați revoluția serverless și deblocați potențialul complet al aplicațiilor dvs. cloud!