Guida rapida: esegui il deployment di un servizio C++ in Cloud Run

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

Prima di iniziare

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.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo

gcloud components
      update

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo

gcloud components
      update

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.

Se un criterio dell'organizzazione con limitazioni di dominio limita le chiamate non autenticate per il tuo progetto, dovrai accedere al servizio di cui è stato eseguito il deployment come descritto in Test dei servizi privati.

scrivi l'applicazione di esempio

Per scrivere un'applicazione in C++:

Crea una nuova directory denominata helloworld-cpp e passa alla directory:
```
mkdir helloworld-cpp
cd helloworld-cpp
```

Crea un nuovo file denominato CMakeLists.txt e incolla il seguente codice al suo interno:

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})

Crea un nuovo file denominato vcpkg.json e incolla il seguente codice al suo interno:

{
  "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"
  ]
}

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.

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.19 AS build

# 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/2024.03.25.tar.gz" | \
    tar --strip-components=1 -zxf - \
    && ./bootstrap-vcpkg.sh -disableMetrics

# Copy the source code to /v/source and compile it.
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 è completa e pronta per il deployment.

Esegui il deployment in Cloud Run dall'origine

Importante: questa guida rapida presuppone che tu disponga dei ruoli di proprietario o editor nel progetto utilizzato per la guida rapida. In caso contrario, consulta Autorizzazioni per il deployment di Cloud Run, Autorizzazioni Cloud Build e Autorizzazioni Artifact Registry per le autorizzazioni necessarie.

Utilizzare Cloud Build per creare un'immagine dal codice sorgente, quindi eseguirne il deployment.

Nella directory di origine, utilizza Cloud Build per creare un'immagine Docker per il tuo servizio
```
gcloud builds submit --machine-type=e2_highcpu_32 --tag gcr.io/PROJECT_ID/cloud-run-hello-world
```
Esegui il deployment dell'immagine utilizzando questo comando:
```
gcloud run deploy --image=gcr.io/PROJECT_ID/cloud-run-hello-world
```
Se ti viene richiesto di abilitare l'API, Rispondi y per abilitarla.
1. Quando ti viene richiesta la posizione del codice sorgente, premi Invio per eseguire il deployment della cartella corrente.
2. Quando ti viene richiesto il nome del servizio, premi Invio per accettare il nome predefinito, ad esempio helloworld.
3. Se ti viene chiesto di abilitare l'API Artifact Registry o di consentire la creazione del repository Artifact Registry, rispondi premendo y.
4. Quando ti viene richiesta l'area geografica, seleziona l'area geografica che preferisci, ad esempio us-central1.
5. Ti verrà chiesto di consentire le chiamate non autenticate: rispondi y .
quindi attendi qualche istante fino al completamento del deployment. Se l'operazione riesce, la riga di comando visualizza l'URL del servizio.
Per visitare il servizio di cui hai eseguito il deployment, apri l'URL del servizio in un browser web.

Località di Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione.

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

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

asia-east1 (Taiwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
europe-north1 (Finlandia) Bassi livelli di CO₂
europe-southwest1 (Madrid)
europe-west1 (Belgio) Bassi livelli di CO₂
europe-west4 (Paesi Bassi)
europe-west8 (Milano)
europe-west9 (Parigi) A basse emissioni di CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) A basse emissioni di CO₂
us-east1 (Carolina del Sud)
us-east4 (Virginia del Nord)
us-east5 (Colombo)
us-south1 (Dallas)
us-west1 (Oregon) Bassi livelli di CO₂

Soggetto ai prezzi di Livello 2

africa-south1 (Johannesburg)
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-west10 (Berlino)
europe-west12 (Torino)
europe-west2 (Londra, Regno Unito) A basse emissioni di CO₂
europe-west3 (Francoforte, Germania) A basse emissioni di CO₂
europe-west6 (Zurigo, Svizzera) A basse emissioni di CO₂
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) A basse emissioni di CO₂
northamerica-northeast2 (Toronto) A basse emissioni di CO₂
southamerica-east1 (San Paolo, Brasile) A basse emissioni di CO₂
southamerica-west1 (Santiago, Cile) A basse emissioni di CO₂
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella console Google Cloud.

Complimenti! Hai appena eseguito il deployment di un'immagine container dal codice sorgente a Cloud Run. Cloud Run esegue lo scale out automatico e orizzontale dell'immagine container per gestire le richieste ricevute, quindi fa lo scale in quando la domanda diminuisce. Paghi solo per la CPU, la memoria e il networking utilizzati durante la gestione delle richieste.

Esegui la pulizia

Rimuovi il progetto di test

Sebbene Cloud Run non addebiti quando il servizio non è in uso, potresti comunque ricevere addebiti per l'archiviazione dell'immagine container in Artifact Registry. Puoi eliminare l'immagine container o il progetto Google Cloud per evitare addebiti. L'eliminazione del tuo progetto Google Cloud interrompe la fatturazione per tutte le risorse utilizzate all'interno di quel progetto.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
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 codice sorgente di codice e sul push a un repository, consulta: