Démarrage rapide : Construire et déployer


// Sample run-helloworld is a minimal Cloud Run service.
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	log.Print("starting server...")
	http.HandleFunc("/", handler)

	// Determine port for HTTP service.
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("defaulting to port %s", port)
	}

	// Start HTTP server.
	log.Printf("listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

func handler(w http.ResponseWriter, r *http.Request) {
	name := os.Getenv("NAME")
	if name == "" {
		name = "World"
	}
	fmt.Fprintf(w, "Hello %s!\n", name)
}

Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

Node.js

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
mkdir helloworld
cd helloworld
```

Créez un fichier package.json avec le contenu suivant :

{
  "name": "helloworld",
  "description": "Simple hello world sample in Node",
  "version": "1.0.0",
  "private": true,
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "engines": {
    "node": ">= 12.0.0"
  },
  "author": "Google LLC",
  "license": "Apache-2.0",
  "dependencies": {
    "express": "^4.17.1"
  }
}

Dans le même répertoire, créez un fichier index.js, puis copiez-y les lignes suivantes :

run/helloworld/index.js

run/helloworld/src/main/java/com/example/helloworld/HelloworldApplication.java

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  const name = process.env.NAME || 'World';
  res.send(`Hello ${name}!`);
});

const port = process.env.PORT || 8080;
app.listen(port, () => {
  console.log(`helloworld: listening on port ${port}`);
});

Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

Python

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
mkdir helloworld
cd helloworld
```
Créez un fichier nommé main.py et collez-y le code suivant :

run/helloworld/main.py

Afficher sur GitHub Commentaires
```
import os

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    name = os.environ.get("NAME", "World")
    return "Hello {}!".format(name)

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
```
Ce code répond aux requêtes avec notre message d'accueil "Hello World!". Le traitement HTTP est effectué par un serveur Web Gunicorn dans le conteneur. Lorsqu'il est appelé directement en local, ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

Java

Créez une application Spring Boot.

À partir de la console, créez un projet Web vide à l'aide des commandes cURL et unzip :
```
curl https://start.spring.io/starter.zip \
    -d dependencies=web \
    -d javaVersion=1.8 \
    -d bootVersion=2.3.3.RELEASE \
    -d name=helloworld \
    -d artifactId=helloworld \
    -d baseDir=helloworld \
    -o helloworld.zip
unzip helloworld.zip
cd helloworld
```
Un projet Spring Boot est créé.

Pour exécuter la commande cURL ci-dessus sous Micosoft Windows, vous devez utiliser l'une des lignes de commande suivantes ou éventuellement Spring Initializr (configuration préchargée) pour générer le projet :
- WSL (recommandé)
- cygwin

Mettez à jour la classe HelloworldApplication dans src/main/java/com/example/helloworld/HelloworldApplication.java en ajoutant une valeur @RestController pour gérer le mappage /, et ajoutez également un champ @Value pour fournir la variable d'environnement NAME :

docs/serving/samples/hello-world/helloworld-csharp/Program.cs


package com.example.helloworld;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class HelloworldApplication {

  @Value("${NAME:World}")
  String name;

  @RestController
  class HelloworldController {
    @GetMapping("/")
    String hello() {
      return "Hello " + name + "!";
    }
  }

  public static void main(String[] args) {
    SpringApplication.run(HelloworldApplication.class, args);
  }
}

Choisissez le port du serveur à définir par la variable d'environnement PORT dans application.properties :

run/helloworld/src/main/resources/application.properties

Afficher sur GitHub Commentaires
```
server.port=${PORT:8080}
```

Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

Pour déployer Java dans Cloud Run avec d'autres frameworks, consultez les exemples Knative pour Spark et Vert.x.

C#

Installez le SDK .NET Core 3.1. Notez que cela n'est nécessaire que pour créer le projet Web à l'étape suivante. Le fichier Docker, décrit ultérieurement, chargera toutes les dépendances dans le conteneur.
À partir de la console, créez un projet Web vide à l'aide de la commande dotnet :
```
dotnet new web -o helloworld-csharp
```
Remplacez le répertoire par helloworld-csharp.

Mettez à jour la définition CreateHostBuilder dans Program.cs pour écouter le port défini par la variable d'environnement PORT :

using System;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace helloworld_csharp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args)
        {
            string port = Environment.GetEnvironmentVariable("PORT") ?? "8080";
            string url = String.Concat("http://0.0.0.0:", port);

            return Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>().UseUrls(url);
                });
        }
    }
}

Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

Créez un fichier nommé Startup.cs et collez-y le code suivant :

docs/serving/samples/hello-world/helloworld-csharp/Startup.cs

using System;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace helloworld_csharp
{
    public class Startup
    {
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapGet("/", async context =>
                {
                    var target = Environment.GetEnvironmentVariable("TARGET") ?? "World";
                    await context.Response.WriteAsync($"Hello {target}!\n");
                });
            });
        }
    }
}

Ce code répond aux requêtes avec notre message d'accueil "Hello World!".

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

C++

Créez un répertoire nommé helloworld-cpp et modifiez les sous-répertoires comme suit :
```
mkdir helloworld-cpp
cd helloworld-cpp
```

Créez un fichier nommé CMakeLists.txt et collez-y le code suivant :

cloud-run-hello-world/CMakeLists.txt

cloud-run-hello-world/cloud_run_hello.cc

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

Créez un fichier nommé cloud_run_hello.cpp et collez-y le code suivant :

#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;
}

Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

PHP

Créez un répertoire nommé helloworld-php et modifiez les sous-répertoires comme suit :
```
mkdir helloworld-php
cd helloworld-php
```
Créez un fichier nommé index.php et collez-y le code suivant :

run/helloworld/index.php

Afficher sur GitHub Commentaires
```
$name = getenv('NAME', true) ?: 'World';
echo sprintf('Hello %s!', $name);
```
Ce code répond aux requêtes avec notre message d'accueil "Hello World!". Le traitement HTTP est effectué par un serveur Web Apache dans le conteneur.

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

Ruby

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
mkdir helloworld
cd helloworld
```
Créez un fichier nommé app.rb et collez-y le code suivant :

run/helloworld/app.rb

Afficher sur GitHub Commentaires
```
require "sinatra"

set :bind, "0.0.0.0"
port = ENV["PORT"] || "8080"
set :port, port

get "/" do
  name = ENV["NAME"] || "World"
  "Hello #{name}!"
end
```
Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

Créez un fichier nommé Gemfile et copiez-y les éléments suivants :

run/helloworld/Gemfile

helloworld-shell/invoke.go

source "https://rubygems.org"

gem "sinatra", "~>2.0"

group :test do
  gem "rack-test"
  gem "rest-client"
  gem "rspec"
  gem "rspec_junit_formatter"
  gem "rubysl-securerandom"
end

Si vous n'avez pas installé Bundler 2.0 ou une version ultérieure, installez Bundler.
Générez un fichier Gemfile.lock en exécutant :

bundle install

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

Shell

Créez un répertoire nommé helloworld-shell et modifiez les sous-répertoires comme suit :
```
mkdir helloworld-shell
cd helloworld-shell
```
Créez un fichier script.sh avec le contenu suivant :

helloworld-shell/script.sh

Afficher sur GitHub Commentaires
```
set -e
echo "Hello ${NAME:-World}!"
```
Afin d'exécuter ce script shell à chaque requête entrante, cet exemple utilise un petit programme Go qui démarre un serveur Web de base et écoute le port défini par la variable d'environnement PORT.

Créez un fichier invoke.go avec le contenu suivant :


// Sample helloworld-shell is a Cloud Run shell-script-as-a-service.
package main

import (
	"log"
	"net/http"
	"os"
	"os/exec"
)

func main() {
	http.HandleFunc("/", scriptHandler)

	// Determine port for HTTP service.
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("Defaulting to port %s", port)
	}

	// Start HTTP server.
	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

func scriptHandler(w http.ResponseWriter, r *http.Request) {
	cmd := exec.CommandContext(r.Context(), "/bin/sh", "script.sh")
	cmd.Stderr = os.Stderr
	out, err := cmd.Output()
	if err != nil {
		w.WriteHeader(500)
	}
	w.Write(out)
}

Votre application est terminée et prête à être conteneurisée, puis importée dans Container Registry.

Autres

Cloud Run est compatible avec la plupart des langages. Pour obtenir des exemples simples dans d'autres langages que ceux présentés dans ce tableau, consultez les pages :

Cependant, dans tous ces exemples, ne tenez pas compte des informations sur service.yaml et Docker Hub, car Cloud Run ne les utilise pas.

Conteneuriser une application et l'importer dans Container Registry

Pour conteneuriser l'exemple d'application, créez un fichier nommé Dockerfile dans le même répertoire que les fichiers sources, puis copiez le contenu suivant :

Go


# Use the offical golang image to create a binary.
# This is based on Debian and sets the GOPATH to /go.
# https://hub.docker.com/_/golang
FROM golang:1.16-buster as builder

# Create and change to the app directory.
WORKDIR /app

# Retrieve application dependencies.
# This allows the container build to reuse cached dependencies.
# Expecting to copy go.mod and if present go.sum.
COPY go.* ./
RUN go mod download

# Copy local code to the container image.
COPY . ./

# Build the binary.
RUN go build -mod=readonly -v -o server

# Use the official Debian slim image for a lean production container.
# https://hub.docker.com/_/debian
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM debian:buster-slim
RUN set -x && apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
    ca-certificates && \
    rm -rf /var/lib/apt/lists/*

# Copy the binary to the production image from the builder stage.
COPY --from=builder /app/server /app/server

# Run the web service on container startup.
CMD ["/app/server"]

Ajoutez un fichier .dockerignore pour exclure des fichiers de votre image de conteneur.

# The .dockerignore file excludes files from the container build process.
#
# https://docs.docker.com/engine/reference/builder/#dockerignore-file

# Exclude locally vendored dependencies.
vendor/

# Exclude "build-time" ignore files.
.dockerignore
.gcloudignore

# Exclude git history and configuration.
.gitignore

Node.js


# Use the official lightweight Node.js 12 image.
# https://hub.docker.com/_/node
FROM node:12-slim

# Create and change to the app directory.
WORKDIR /usr/src/app

# Copy application dependency manifests to the container image.
# A wildcard is used to ensure copying both package.json AND package-lock.json (when available).
# Copying this first prevents re-running npm install on every code change.
COPY package*.json ./

# Install production dependencies.
# If you add a package-lock.json, speed your build by switching to 'npm ci'.
# RUN npm ci --only=production
RUN npm install --only=production

# Copy local code to the container image.
COPY . ./

# Run the web service on container startup.
CMD [ "node", "index.js" ]

Ajoutez un fichier .dockerignore pour exclure des fichiers de votre image de conteneur.

Dockerfile
.dockerignore
node_modules
npm-debug.log

Python

Le fichier Dockerfile Python démarre un serveur Web Firicorn, qui écoute le port défini par la variable d'environnement PORT :


# Use the official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.9-slim

# Allow statements and log messages to immediately appear in the Knative logs
ENV PYTHONUNBUFFERED True

# Copy local code to the container image.
ENV APP_HOME /app
WORKDIR $APP_HOME
COPY . ./

# Install production dependencies.
RUN pip install Flask gunicorn

# Run the web service on container startup. Here we use the gunicorn
# webserver, with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
# Timeout is set to 0 to disable the timeouts of the workers to allow Cloud Run to handle instance scaling.
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

Ajoutez un fichier .dockerignore pour exclure des fichiers de votre image de conteneur.

Dockerfile
README.md
*.pyc
*.pyo
*.pyd
__pycache__
.pytest_cache

Java


# Use the official maven/Java 8 image to create a build artifact.
# https://hub.docker.com/_/maven
FROM maven:3.6-jdk-11 as builder

# Copy local code to the container image.
WORKDIR /app
COPY pom.xml .
COPY src ./src

# Build a release artifact.
RUN mvn package -DskipTests

# Use AdoptOpenJDK for base image.
# It's important to use OpenJDK 8u191 or above that has container support enabled.
# https://hub.docker.com/r/adoptopenjdk/openjdk8
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM adoptopenjdk/openjdk11:alpine-slim

# Copy the jar to the production image from the builder stage.
COPY --from=builder /app/target/helloworld-*.jar /helloworld.jar

# Run the web service on container startup.
CMD ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/helloworld.jar"]

Ajoutez un fichier .dockerignore pour exclure des fichiers de votre image de conteneur.

docs/serving/samples/hello-world/helloworld-csharp/Dockerfile

Dockerfile
.dockerignore
target/

C#

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/core/sdk:3.1-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-alpine AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "helloworld-csharp.dll"]

Pour empêcher l'importation de fichiers générés par des opérations de compilation dotnet locales dans Cloud Build, ajoutez un fichier .gcloudignore dans le même répertoire que les fichiers sources de l'exemple d'application :

run/helloworld/.gcloudignore

# The .gcloudignore file excludes file from upload to Cloud Build.
# If this file is deleted, gcloud will default to .gitignore.
#
# https://cloud.google.com/cloud-build/docs/speeding-up-builds#gcloudignore
# https://cloud.google.com/sdk/gcloud/reference/topic/gcloudignore

**/obj/
**/bin/

# Exclude git history and configuration.
.git/
.gitignore

Si ces lignes se trouvent dans un fichier .gitignore, vous pouvez passer cette étape car .gitignore est une source par défaut pour la configuration .gcloudignore.

Copiez ces lignes dans un fichier .dockerignore pour les builds de conteneurs locaux en utilisant l'outil de ligne de commande docker.

C++

Le fichier Dockerfile C++ démarre l'application en écoute sur le port défini par la variable d'environnement PORT :

cloud-run-hello-world/Dockerfile

# 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" ]

PHP

Le fichier Dockerfile PHP démarre un serveur Web Apache qui écoute le port défini par la variable d'environnement PORT :


# Use the official PHP image.
# https://hub.docker.com/_/php
FROM php:7.4-apache

# Configure PHP for Cloud Run.
# Precompile PHP code with opcache.
RUN docker-php-ext-install -j "$(nproc)" opcache
RUN set -ex; \
  { \
    echo "; Cloud Run enforces memory & timeouts"; \
    echo "memory_limit = -1"; \
    echo "max_execution_time = 0"; \
    echo "; File upload at Cloud Run network limit"; \
    echo "upload_max_filesize = 32M"; \
    echo "post_max_size = 32M"; \
    echo "; Configure Opcache for Containers"; \
    echo "opcache.enable = On"; \
    echo "opcache.validate_timestamps = Off"; \
    echo "; Configure Opcache Memory (Application-specific)"; \
    echo "opcache.memory_consumption = 32"; \
  } > "$PHP_INI_DIR/conf.d/cloud-run.ini"

# Copy in custom code from the host machine.
WORKDIR /var/www/html
COPY . ./

# Use the PORT environment variable in Apache configuration files.
# https://cloud.google.com/run/docs/reference/container-contract#port
RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf

# Configure PHP for development.
# Switch to the production php.ini for production operations.
# RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
# https://github.com/docker-library/docs/blob/master/php/README.md#configuration
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"

Ajoutez un fichier .dockerignore pour exclure des fichiers de votre image de conteneur.

# The .dockerignore file excludes files from the container build process.
#
# https://docs.docker.com/engine/reference/builder/#dockerignore-file

# Exclude locally vendored dependencies.
vendor/

# Exclude "build-time" ignore files.
.dockerignore
.gcloudignore

# Exclude git history and configuration.
.gitignore

Ruby


# Use the official lightweight Ruby image.
# https://hub.docker.com/_/ruby
FROM ruby:2.5-slim

# Install production dependencies.
WORKDIR /usr/src/app
COPY Gemfile Gemfile.lock ./
ENV BUNDLE_FROZEN=true
RUN gem install bundler && bundle install --without test

# Copy local code to the container image.
COPY . ./

# Run the web service on container startup.
CMD ["ruby", "./app.rb"]

Ajoutez un fichier .dockerignore pour exclure des fichiers de votre image de conteneur.

helloworld-shell/Dockerfile

Dockerfile
README.md
.ruby-version
.bundle/
vendor/

Shell