Compila e implementa un servicio C++

Aprende a crear una aplicación simple de Hello World, empaquetarla en una imagen de contenedor, subirla a Container Registry y, luego, implementarla en Cloud Run. Puedes usar otros lenguajes además de los que se muestran.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. Instala e inicializa el SDK de Cloud.

Escribe la aplicación de muestra

Si deseas escribir una aplicación en C++, haz lo siguiente:

  1. Crea un directorio nuevo llamado helloworld-cpp y usa el comando de cambio de directorio en él:

    mkdir helloworld-cpp
    cd helloworld-cpp
    
  2. Crea un archivo nuevo llamado CMakeLists.txt y pega el siguiente código en él:

    cmake_minimum_required(VERSION 3.10)
    
    # 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 C)
    
    # Configure the Compiler options, we will be using C++17 features.
    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
    
    find_package(Boost 1.66 REQUIRED COMPONENTS program_options)
    find_package(Threads)
    
    add_executable(cloud_run_hello cloud_run_hello.cc)
    target_link_libraries(
      cloud_run_hello PRIVATE Boost::headers Boost::program_options
                              Threads::Threads)
    
    include(GNUInstallDirs)
    install(TARGETS cloud_run_hello RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
  3. Crea un archivo nuevo llamado cloud_run_hello.cc y pega el siguiente código en él:

    #include <boost/asio/ip/tcp.hpp>
    #include <boost/asio/strand.hpp>
    #include <boost/beast/core.hpp>
    #include <boost/beast/http.hpp>
    #include <boost/beast/version.hpp>
    #include <boost/program_options.hpp>
    #include <cstdlib>
    #include <iostream>
    #include <optional>
    #include <thread>
    
    namespace be = boost::beast;
    namespace asio = boost::asio;
    namespace po = boost::program_options;
    using tcp = boost::asio::ip::tcp;
    
    po::variables_map parse_args(int& argc, char* argv[]) {
      // Initialize the default port with the value from the "PORT" environment
      // variable or with 8080.
      auto port = [&]() -> std::uint16_t {
        auto env = std::getenv("PORT");
        if (env == nullptr) return 8080;
        auto value = std::stoi(env);
        if (value < std::numeric_limits<std::uint16_t>::min() ||
            value > std::numeric_limits<std::uint16_t>::max()) {
          std::ostringstream os;
          os << "The PORT environment variable value (" << value
             << ") is out of range.";
          throw std::invalid_argument(std::move(os).str());
        }
        return static_cast<std::uint16_t>(value);
      }();
    
      // Parse the command-line options.
      po::options_description desc("Server configuration");
      desc.add_options()
          //
          ("help", "produce help message")
          //
          ("address", po::value<std::string>()->default_value("0.0.0.0"),
           "set listening address")
          //
          ("port", po::value<std::uint16_t>()->default_value(port),
           "set listening port");
    
      po::variables_map vm;
      po::store(po::parse_command_line(argc, argv, desc), vm);
      po::notify(vm);
      if (vm.count("help")) {
        std::cout << desc << "\n";
      }
      return vm;
    }
    
    int main(int argc, char* argv[]) try {
      po::variables_map vm = parse_args(argc, argv);
    
      if (vm.count("help")) return 0;
    
      auto address = asio::ip::make_address(vm["address"].as<std::string>());
      auto port = vm["port"].as<std::uint16_t>();
      std::cout << "Listening on " << address << ":" << port << std::endl;
    
      auto handle_session = [](tcp::socket socket) {
        auto report_error = [](be::error_code ec, char const* what) {
          std::cerr << what << ": " << ec.message() << "\n";
        };
    
        be::error_code ec;
        for (;;) {
          be::flat_buffer buffer;
    
          // Read a request
          be::http::request<be::http::string_body> request;
          be::http::read(socket, buffer, request, ec);
          if (ec == be::http::error::end_of_stream) break;
          if (ec) return report_error(ec, "read");
    
          // Send the response
          // Respond to any request with a "Hello World" message.
          be::http::response<be::http::string_body> response{be::http::status::ok,
                                                             request.version()};
          response.set(be::http::field::server, BOOST_BEAST_VERSION_STRING);
          response.set(be::http::field::content_type, "text/plain");
          response.keep_alive(request.keep_alive());
          std::string greeting = "Hello ";
          auto const* target = std::getenv("TARGET");
          greeting += target == nullptr ? "World" : target;
          greeting += "\n";
          response.body() = std::move(greeting);
          response.prepare_payload();
          be::http::write(socket, response, ec);
          if (ec) return report_error(ec, "write");
        }
        socket.shutdown(tcp::socket::shutdown_send, ec);
      };
    
      asio::io_context ioc{/*concurrency_hint=*/1};
      tcp::acceptor acceptor{ioc, {address, port}};
      for (;;) {
        auto socket = acceptor.accept(ioc);
        if (!socket.is_open()) break;
        // Run a thread per-session, transferring ownership of the socket
        std::thread{handle_session, std::move(socket)}.detach();
      }
    
      return 0;
    } catch (std::exception const& ex) {
      std::cerr << "Standard exception caught " << ex.what() << '\n';
      return 1;
    }

    Con este código, se crea un servidor web básico que escucha en el puerto definido por la variable de entorno PORT.

  4. Crea un archivo nuevo llamado Dockerfile en el mismo directorio que los archivos fuente. El Dockerfile de C++ inicia la aplicación que escucha en el puerto definido por la variable de entorno PORT:

    # We chose Alpine to build the image because it has good support for creating
    # statically-linked, small programs.
    ARG DISTRO_VERSION=edge
    FROM alpine:${DISTRO_VERSION} 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 and some additions:
    #   - ninja-build is a backend for CMake that often compiles faster than
    #     CMake with GNU Make.
    #   - Install the boost libraries.
    RUN apk update && \
        apk add \
            boost-dev \
            boost-static \
            build-base \
            cmake \
            git \
            gcc \
            g++ \
            libc-dev \
            nghttp2-static \
            ninja \
            openssl-dev \
            openssl-libs-static \
            tar \
            zlib-static
    
    # 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_BUILD_TYPE=Release \
        -DBoost_USE_STATIC_LIBS=ON \
        -DCMAKE_EXE_LINKER_FLAGS=-static
    
    # 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 make it the entry point.
    COPY --from=build /v/binary/cloud_run_hello /r
    
    ENTRYPOINT [ "/r/cloud_run_hello" ]

La app está lista para implementarse.

Implementa en Cloud Run desde la fuente

Importante: En esta guía de inicio rápido, se supone que tienes funciones de propietario o de editor en el proyecto que usas para la guía de inicio rápido. De lo contrario, consulta los permisos de implementación de Cloud Run, los permisos de Cloud Build y los permisos de Artifact Registry para conocer los permisos necesarios.

Para implementar la imagen de contenedor, haz lo siguiente:

  1. Realiza la implementación desde la fuente con el siguiente comando:

    gcloud run deploy

    Si se te solicita que habilites la API, presiona y para habilitarla.

    1. Cuando se te solicite la ubicación del código fuente, presiona Intro para implementar la carpeta actual.

    2. Cuando se te solicite el nombre del servicio, presiona Intro para aceptar el nombre predeterminado, helloworld.

    3. Si se te solicita que habilites la API de Artifact Registry, presiona “y” para responder.

    4. Cuando se te solicite la región, selecciona la región que prefieras, por ejemplo, us-central1.

    5. Se te solicitará permitir invocaciones no autenticadas; responde y.

    Luego, espera un momento a que finalice la implementación. Si la operación se completa de forma correcta, la línea de comandos mostrará la URL de servicio.

  2. Abre la URL de servicio en un navegador web para visitar el servicio implementado.

Ubicaciones de Cloud Run

Cloud Run es regional, lo que significa que la infraestructura que ejecuta los servicios se ubica en una región específica, y Google la administra para que esté disponible de manera redundante en todas las zonas de esa región.

El cumplimiento de los requisitos de latencia, disponibilidad o durabilidad es el factor principal para seleccionar la región en la que se ejecutan los servicios de Cloud Run. Por lo general, puedes seleccionar la región más cercana a los usuarios, pero debes considerar la ubicación de los otros productos de Google Cloud que usa el servicio de Cloud Run. Si usas productos de Google Cloud en varias ubicaciones, la latencia y el costo del servicio pueden verse afectados.

Cloud Run está disponible en las siguientes regiones:

Sujetas a los Precios del nivel 1

Sujetas a los Precios del nivel 2

  • asia-east2 (Hong Kong)
  • asia-northeast3 (Seúl, Corea del Sur)
  • asia-southeast1 (Singapur)
  • asia-southeast2 (Yakarta)
  • asia-south1 (Bombay, India)
  • asia-south2 Delhi (India)
  • australia-southeast1 (Sídney)
  • australia-southeast2 (Melbourne)
  • europe-central2 (Varsovia, Polonia)
  • europe-west2 (Londres, Reino Unido)
  • europe-west3 (Fráncfort, Alemania)
  • europe-west6 (Zúrich, Suiza) Ícono de la hoja Bajo nivel de CO2
  • northamerica-northeast1 (Montreal) Ícono de la hoja Bajo nivel de CO2
  • northamerica-northeast2 (Toronto)
  • southamerica-east1 (São Paulo, Brasil) Ícono de la hoja Bajo nivel de CO2
  • us-west2 (Los Ángeles)
  • us-west3 (Las Vegas)
  • us-west4 (Salt Lake City)

Si ya creaste un servicio de Cloud Run, puedes ver la región en el panel de Cloud Run en Cloud Console.

¡Felicitaciones! Acaba de implementar una imagen de contenedor del código fuente en Cloud Run. Cloud Run reduce la escala de la imagen de contenedor de forma automática y horizontal para controlar las solicitudes que se reciben y, luego, escala horizontalmente cuando disminuye la demanda. Solo debes pagar por la CPU, la memoria y las herramientas de redes que se utilicen durante la administración de la solicitud.

Limpia

Quita el proyecto de prueba

Si bien Cloud Run no cobra cuando el servicio no se usa, es posible que se te cobre por el almacenamiento de la imagen de contenedor en Container Registry. Puedes borrar la imagen o borrar el proyecto de Cloud para evitar que se apliquen cargos. Si borras el proyecto de Cloud, se dejan de facturar todos los recursos que usaste en ese proyecto.

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

Para obtener más información sobre cómo compilar un contenedor a partir del código fuente y enviarlo a un repositorio, consulta los siguientes vínculos: