Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.
Guida rapida: deployment di un servizio C++ in Cloud Run

Deployment di un servizio C++ in Cloud Run

Scopri come creare una semplice applicazione Hello World, pacchettizzarla in un'immagine container, caricarla in Container Registry ed eseguire il deployment dell'immagine container su Cloud Run. Puoi utilizzare altre lingue oltre a quelle mostrate.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Installa e inizializza Google Cloud CLI.
  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Installa e inizializza Google Cloud CLI.
    1. Per impostare il progetto predefinito per il tuo servizio Cloud Run:
       gcloud config set project PROJECT_ID
      Sostituisci PROJECT_ID con il nome del progetto che hai creato per questa guida rapida.

scrivi l'applicazione di esempio

Per scrivere un'applicazione in C++:

  1. Crea una nuova directory denominata helloworld-cpp e modificala al suo interno:

    mkdir helloworld-cpp
    cd helloworld-cpp
    
  2. Crea un nuovo file denominato CMakeLists.txt e incolla al suo interno il seguente codice:

    cmake_minimum_required(VERSION 3.20)
    
    # Define the project name and where to report bugs.
    set(PACKAGE_BUGREPORT
        "https://github.com/GoogleCloudPlatform/cpp-samples/issues")
    project(cpp-samples-cloud-run-hello-world CXX)
    
    find_package(functions_framework_cpp REQUIRED)
    find_package(Threads)
    
    add_executable(cloud_run_hello cloud_run_hello.cc)
    target_compile_features(cloud_run_hello PRIVATE cxx_std_17)
    target_link_libraries(cloud_run_hello functions-framework-cpp::framework)
    
    include(GNUInstallDirs)
    install(TARGETS cloud_run_hello RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
  3. Crea un nuovo file denominato vcpkg.json e incolla al suo interno il seguente codice:

    {
      "name": "cpp-samples-cloud-run-hello-world",
      "version-string": "unversioned",
      "homepage": "https://github.com/GoogleCloudPlatform/cpp-samples/",
      "description": [
        "Shows how to deploy a C++ application to Cloud Run."
      ],
      "dependencies": [
        "functions-framework-cpp"
      ]
    }
    
  4. Crea un nuovo file denominato cloud_run_hello.cc e incolla il seguente codice al suo interno:

    #include <google/cloud/functions/framework.h>
    #include <cstdlib>
    
    namespace gcf = ::google::cloud::functions;
    
    auto hello_world_http() {
      return gcf::MakeFunction([](gcf::HttpRequest const& /*request*/) {
        std::string greeting = "Hello ";
        auto const* target = std::getenv("TARGET");
        greeting += target == nullptr ? "World" : target;
        greeting += "\n";
    
        return gcf::HttpResponse{}
            .set_header("Content-Type", "text/plain")
            .set_payload(greeting);
      });
    }
    
    int main(int argc, char* argv[]) {
      return gcf::Run(argc, argv, hello_world_http());
    }
    

    Questo codice crea un server web di base in ascolto sulla porta definita dalla variabile di ambiente PORT.

  5. Crea un nuovo file denominato Dockerfile nella stessa directory dei file di origine. Il Dockerfile C++ avvia l'applicazione in ascolto sulla porta definita dalla variabile di ambiente PORT:

    # We chose Alpine to build the image because it has good support for creating
    # statically-linked, small programs.
    FROM alpine:3.16 AS base
    
    # Create separate targets for each phase, this allows us to cache intermediate
    # stages when using Google Cloud Build, and makes the final deployment stage
    # small as it contains only what is needed.
    FROM base AS devtools
    
    # Install the typical development tools for C++, and
    # the base OS headers and libraries.
    RUN apk update && \
        apk add \
            build-base \
            cmake \
            curl \
            git \
            gcc \
            g++ \
            libc-dev \
            linux-headers \
            ninja \
            pkgconfig \
            tar \
            unzip \
            zip
    
    # Use `vcpkg`, a package manager for C++, to install
    WORKDIR /usr/local/vcpkg
    ENV VCPKG_FORCE_SYSTEM_BINARIES=1
    RUN curl -sSL "https://github.com/Microsoft/vcpkg/archive/2022.07.25.tar.gz" | \
        tar --strip-components=1 -zxf - \
        && ./bootstrap-vcpkg.sh -disableMetrics
    
    # Copy the source code to /v/source and compile it.
    FROM devtools AS build
    COPY . /v/source
    WORKDIR /v/source
    
    # Run the CMake configuration step, setting the options to create
    # a statically linked C++ program
    RUN cmake -S/v/source -B/v/binary -GNinja \
        -DCMAKE_TOOLCHAIN_FILE=/usr/local/vcpkg/scripts/buildsystems/vcpkg.cmake \
        -DCMAKE_BUILD_TYPE=Release
    
    # Compile the binary and strip it to reduce its size.
    RUN cmake --build /v/binary
    RUN strip /v/binary/cloud_run_hello
    
    # Create the final deployment image, using `scratch` (the empty Docker image)
    # as the starting point. Effectively we create an image that only contains
    # our program.
    FROM scratch AS cloud-run-hello
    WORKDIR /r
    
    # Copy the program from the previously created stage and the shared libraries it
    # depends on.
    COPY --from=build /v/binary/cloud_run_hello /r
    COPY --from=build /lib/ld-musl-x86_64.so.1 /lib/ld-musl-x86_64.so.1
    COPY --from=build /usr/lib/libstdc++.so.6 /usr/lib/libstdc++.so.6
    COPY --from=build /usr/lib/libgcc_s.so.1 /usr/lib/libgcc_s.so.1
    
    # Make the program the entry point.
    ENTRYPOINT [ "/r/cloud_run_hello" ]

L'app è stata completata e il deployment è pronto.

Esegui il deployment in Cloud Run dall'origine

Importante: questa guida rapida presuppone che tu abbia i ruoli di proprietario o di editor nel progetto che stai utilizzando per la guida rapida. In caso contrario, consulta le autorizzazioni di deployment di Cloud Run, le autorizzazioni di Cloud Build e le autorizzazioni di Artifact Registry per le autorizzazioni richieste.

Utilizza Cloud Build per creare un'immagine dal codice sorgente e quindi eseguirne il deployment.

  1. Nella directory di origine, utilizza Cloud Build per creare un'immagine docker per il servizio

    gcloud builds submit --machine-type=e2_highcpu_32 --tag gcr.io/PROJECT_ID/cloud-run-hello-world
  2. Esegui il deployment dell'immagine utilizzando il seguente comando:

    gcloud run deploy --image=gcr.io/PROJECT_ID/cloud-run-hello-world

    Se ti viene richiesto di abilitare l'API, rispondi y per attivarla.

    1. Quando ti viene chiesto di eseguire la posizione del codice sorgente, premi Invio per eseguire il deployment della cartella corrente.

    2. Quando ti viene chiesto il nome del servizio, premi Invio per accettare il nome predefinito, helloworld.

    3. Se ti viene chiesto di abilitare l'API Artifact Registry, rispondi premendo y.

    4. Quando viene richiesta la regione: seleziona la regione che preferisci, ad esempio us-central1.

    5. Ti verrà chiesto di consentire chiamate non autenticate: rispondi y .

    Attendi qualche istante fino al completamento del deployment. Se l'operazione riesce, la riga di comando visualizza l'URL del servizio.

  3. Visita il servizio di cui hai eseguito il deployment aprendo l'URL del servizio in un browser web.

Località di Cloud Run

Cloud Run è a livello di regione, ossia l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google in modo che sia ridondante disponibile in tutte le zone al suo interno.

Soddisfare i requisiti di latenza, disponibilità o durabilità sono fattori principali per la selezione dell'area geografica in cui vengono eseguiti i servizi Cloud Run. In genere, puoi selezionare l'area geografica più vicina ai tuoi utenti, ma dovresti considerare la località degli altri prodotti Google Cloud utilizzati dal servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire sulla latenza del servizio e sui costi.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

  • asia-east1 (Taiwan)
  • asia-northeast1 (Tokyo)
  • asia-northeast2 (Osaka)
  • europe-north1 (Finlandia) icona Fogliolina Bassi livelli di CO2
  • europe-southwest1 (Madrid) icona Fogliolina CO bassa2
  • europe-west1 (Belgio) icona Fogliolina CO bassa2
  • europe-west4 (Paesi Bassi)
  • europe-west8 (Milano)
  • europe-west9 (Parigi) icona Fogliolina Basso livello di CO2
  • us-central1 (Iowa) icona Fogliolina CO basso2
  • us-east1 (Carolina del Sud)
  • us-east4 (Virginia del Nord)
  • us-east5 (Columbus)
  • us-south1 (Dallas)
  • us-west1 (Oregon) icona Fogliolina Bassi livelli di CO2

Soggetto ai prezzi di Livello 2

  • asia-east2 (Hong Kong)
  • asia-northeast3 (Seul, Corea del Sud)
  • asia-southeast1 (Singapore)
  • asia-southeast2 (Giacarta)
  • asia-south1 (Mumbai, India)
  • asia-south2 (Delhi, India)
  • australia-southeast1 (Sydney)
  • australia-southeast2 (Melbourne)
  • europe-central2 (Varsavia, Polonia)
  • europe-west2 (Londra, Regno Unito)
  • europe-west3 (Francoforte, Germania)
  • europe-west6 (Zurigo, Svizzera) icona Fogliolina Basso livello di CO2
  • northamerica-northeast1 (Montreal) icona Fogliolina CO bassa2
  • northamerica-northeast2 (Toronto) icona Fogliolina Basso livello di CO2
  • southamerica-east1 (San Paolo, Brasile) icona Fogliolina Basso CO2
  • southamerica-west1 (Santiago, Cile)
  • us-west2 (Los Angeles)
  • us-west3 (Salt Lake City)
  • us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare l'area geografica nella dashboard di Cloud Run nella Google Cloud Console.

Complimenti! Hai appena eseguito il deployment di un'immagine container dal codice sorgente in Cloud Run. Cloud Run scala automaticamente e orizzontalmente l'immagine container per gestire le richieste ricevute, quindi fa lo scale down quando la domanda diminuisce. Paghi solo per la CPU, la memoria e le reti utilizzate durante la gestione delle richieste.

Esegui la pulizia

Rimuovi il progetto di test

Sebbene non siano previsti addebiti per Cloud Run quando il servizio non è in uso, ti potrebbero comunque essere addebitati i costi di archiviazione dell'immagine container in Artifact Registry. Per evitare incorrere in addebiti, puoi eliminare l'immagine container o eliminare il progetto Cloud. L'eliminazione del tuo progetto Cloud interrompe la fatturazione per tutte le risorse utilizzate all'interno di quel progetto.

  1. In Google Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Per saperne di più sulla creazione di un container da un'origine codice e sul push in un repository, consulta: