M

MLOG

Polski

Odkryj moc przetwarzania bezserwerowego dzięki Google Cloud Functions. Ten przewodnik analizuje wyzwalacze HTTP, dostarczając programistom na całym świecie wiedzę potrzebną do tworzenia skalowalnych aplikacji opartych na zdarzeniach.

Google Cloud Functions: Kompleksowy przewodnik po wyzwalaczach HTTP

Google Cloud Functions (GCF) to środowisko wykonawcze bezserwerowe, które umożliwia tworzenie usług w chmurze i łączenie się z nimi. Dzięki Cloud Functions piszesz proste, wyspecjalizowane funkcje, które są powiązane ze zdarzeniami emitowanymi z infrastruktury i usług chmurowych. Twoja funkcja jest wykonywana, gdy wystąpi obserwowane przez Ciebie zdarzenie. Takie podejście pozwala na tworzenie aplikacji opartych na zdarzeniach bez zarządzania serwerami lub środowiskami uruchomieniowymi.

Jednym z najczęstszych sposobów wywoływania Cloud Function jest żądanie HTTP. Ten przewodnik zagłębi się w świat wyzwalaczy HTTP w Google Cloud Functions, dostarczając wiedzę potrzebną do budowania wydajnych, skalowalnych i opłacalnych aplikacji.

Czym są wyzwalacze HTTP?

Wyzwalacz HTTP umożliwia wykonanie Cloud Function w odpowiedzi na żądanie HTTP. Zasadniczo, gdy żądanie HTTP zostanie wysłane do określonego adresu URL, Google Cloud Functions automatycznie wykona powiązaną funkcję. To sprawia, że wyzwalacze HTTP są idealne do tworzenia API, webhooków i aplikacji internetowych opartych na zdarzeniach.

Kluczowe zalety stosowania wyzwalaczy HTTP:

Tworzenie Cloud Function z wyzwalaczem HTTP

Przejdźmy przez proces tworzenia prostej Cloud Function z wyzwalaczem HTTP. Utworzymy funkcję, która odpowiada komunikatem "Hello, World!". Ten przykład można dostosować do różnych globalnych ustawień regionalnych, po prostu modyfikując ciąg wyjściowy.

Wymagania wstępne:

Kroki:

  1. Utwórz nowy projekt (jeśli go nie masz):

    Jeśli nie masz jeszcze projektu GCP, utwórz go w konsoli Google Cloud.

  2. Włącz Cloud Functions API:

    W konsoli Cloud przejdź do Cloud Functions API i włącz je.

  3. Utwórz katalog funkcji:

    Utwórz nowy katalog dla Cloud Function. Na przykład:

    mkdir hello-http
cd hello-http
  4. Napisz kod funkcji:

    Utwórz plik o nazwie `main.py` (lub `index.js` dla Node.js) z następującym kodem:

    Python (main.py):

    def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        <https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request>
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `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. Utwórz plik wymagań (tylko Python):

    Jeśli używasz języka Python, utwórz plik o nazwie `requirements.txt` i dodaj wszystkie zależności, których potrzebuje Twoja funkcja. W tym przykładzie nie jest to absolutnie konieczne, ale dobrą praktyką jest dołączenie go. Możesz go pozostawić pusty, jeśli nie masz żadnych zależności.

  6. Wdróż funkcję:

    Użyj polecenia `gcloud functions deploy`, aby wdrożyć funkcję. Zastąp `YOUR_FUNCTION_NAME` żądaną nazwą funkcji.

    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

    Wyjaśnienie parametrów:

    • `YOUR_FUNCTION_NAME`: Nazwa, którą chcesz nadać Cloud Function.
    • `--runtime`: Środowisko uruchomieniowe dla funkcji (np. `python39`, `nodejs16`).
    • `--trigger-http`: Określa, że funkcja powinna być wyzwalana przez żądania HTTP.
    • `--allow-unauthenticated`: Umożliwia każdemu wywoływanie funkcji bez uwierzytelniania. Ostrzeżenie: Zachowaj ostrożność podczas włączania tej opcji w środowiskach produkcyjnych! Rozważ wdrożenie odpowiedniego uwierzytelniania i autoryzacji.
  7. Przetestuj funkcję:

    Po wdrożeniu polecenie `gcloud` wyświetli adres URL funkcji. Możesz go następnie przetestować, wysyłając żądanie HTTP na ten adres URL za pomocą narzędzia takiego jak `curl` lub Postman.

    curl YOUR_FUNCTION_URL

    Powinieneś zobaczyć komunikat "Hello, World!" w odpowiedzi. Możesz również przekazać imię jako parametr zapytania:

    curl "YOUR_FUNCTION_URL?name=YourName"

    Powinno to zwrócić "Hello, YourName!"

Zrozumienie żądania i odpowiedzi HTTP

Gdy Cloud Function jest wywoływana przez żądanie HTTP, otrzymuje obiekt zawierający informacje o żądaniu. Obiekt ten zazwyczaj zawiera:

Funkcja powinna następnie zwrócić odpowiedź HTTP, która zawiera:

Przykład: Obsługa różnych metod HTTP

Oto przykład, jak obsługiwać różne metody HTTP w 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`<https://flask.palletsprojects.com/en/2.0.x/api/#flask.Flask.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;
  }
};

Pamiętaj, aby wdrożyć zaktualizowaną funkcję za pomocą polecenia `gcloud functions deploy`.

Zabezpieczanie wyzwalaczy HTTP

Bezpieczeństwo jest najważniejsze podczas pracy z wyzwalaczami HTTP, zwłaszcza gdy masz do czynienia z poufnymi danymi lub krytycznymi operacjami. Oto kilka kluczowych kwestii dotyczących bezpieczeństwa:

Uwierzytelnianie i autoryzacja

Domyślnie Cloud Functions wywoływane przez HTTP są publicznie dostępne, jeśli używasz `--allow-unauthenticated`. W większości scenariuszy produkcyjnych będziesz chciał ograniczyć dostęp do autoryzowanych użytkowników lub usług. Google Cloud udostępnia kilka opcji uwierzytelniania i autoryzacji:

Walidacja danych wejściowych

Zawsze sprawdzaj poprawność danych wejściowych odbieranych przez Cloud Function, aby zapobiec lukom w zabezpieczeniach, takim jak wstrzykiwanie SQL lub cross-site scripting (XSS). Użyj odpowiednich technik sanityzacji i maskowania, aby chronić się przed złośliwymi danymi wejściowymi.

HTTPS

Upewnij się, że Cloud Function jest dostępna tylko przez HTTPS, aby szyfrować komunikację między klientem a funkcją. Google Cloud Functions automatycznie udostępnia punkty końcowe HTTPS.

Ograniczanie szybkości

Zaimplementuj ograniczanie szybkości, aby zapobiec nadużyciom i atakom typu "odmowa usługi" (DoS). Możesz użyć usług takich jak Google Cloud Armor, aby chronić Cloud Functions przed nadmiernym ruchem.

Przypadki użycia dla wyzwalaczy HTTP

Wyzwalacze HTTP są wszechstronne i mogą być używane w szerokim zakresie aplikacji. Oto kilka typowych przypadków użycia:

Przykłady z różnych branż

Zaawansowane techniki

Korzystanie ze zmiennych środowiskowych

Zmienne środowiskowe umożliwiają konfigurowanie Cloud Function bez wprowadzania na stałe poufnych informacji lub wartości konfiguracyjnych w kodzie. Możesz ustawić zmienne środowiskowe za pomocą polecenia `gcloud functions deploy` lub w konsoli Google Cloud.

gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=YOUR_API_KEY,DATABASE_URL=YOUR_DATABASE_URL

W kodzie możesz uzyskać dostęp do zmiennych środowiskowych za pomocą słownika `os.environ` (Python) lub obiektu `process.env` (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}`);
};

Obsługa zadań asynchronicznych

W przypadku długotrwałych lub wymagających obliczeniowo zadań najlepiej jest użyć przetwarzania asynchronicznego, aby uniknąć blokowania żądania HTTP. Możesz użyć usług takich jak Google Cloud Tasks lub Cloud Pub/Sub, aby przenieść te zadania do oddzielnych kolejek.

Obsługa błędów i rejestrowanie

Zaimplementuj solidną obsługę błędów i rejestrowanie w Cloud Functions, aby szybko identyfikować i rozwiązywać problemy. Użyj Google Cloud Logging, aby zbierać dzienniki z funkcji i monitorować ich wydajność.

Najlepsze praktyki

Rozwiązywanie typowych problemów

Podsumowanie

Google Cloud Functions z wyzwalaczami HTTP zapewniają potężny i elastyczny sposób budowania aplikacji bezserwerowych. Rozumiejąc koncepcje i techniki omówione w tym przewodniku, możesz wykorzystać moc Cloud Functions do tworzenia skalowalnych, opłacalnych i opartych na zdarzeniach rozwiązań dla globalnej publiczności. Wykorzystaj rewolucję bezserwerową i odblokuj pełny potencjał swoich aplikacji w chmurze!