Exiba conteúdo dinâmico e hospede microsserviços com o Cloud Run

No momento, o

Combine Cloud Run com Firebase Hosting para gerar e exibir seu conteúdo dinâmico ou criar APIs REST como microsserviços.

Ao usar o Cloud Run, é possível implantar um aplicativo empacotado em uma imagem de contêiner. Em seguida, com Firebase Hosting, é possível direcionar solicitações HTTPS para acionar seu aplicativo conteinerizado.

  • O Cloud Run tem suporte a várias linguagens, incluindo Go, Node.js, Python e Java, dando a você a flexibilidade de usar a linguagem de programação e o framework de sua escolha.
  • O Cloud Run escalona automática e horizontalmente a imagem do seu contêiner para lidar com as solicitações recebidas e reduz o escalonamento quando a demanda diminui.
  • Você paga apenas pela CPU, memória e rede consumidas durante o processamento da solicitação.

Se você quiser encontrar exemplos de casos de uso e amostras do Cloud Run integrado ao Firebase Hosting, acesse nossa visão geral de opções sem servidor.


Confira neste guia como realizar os procedimentos a seguir:

  1. Criar um simples aplicativo Hello World.
  2. Conteinerizar um app e fazer upload dele para o Artifact Registry
  3. Implantar a imagem do contêiner no Cloud Run
  4. Direcionar solicitações do Hosting para seu aplicativo conteinerizado.

Observe que, para melhorar o desempenho da exibição de conteúdo dinâmico, é possível, opcionalmente, ajustar suas configurações de cache.

Antes de começar

Antes de usar o Cloud Run, você precisa concluir algumas tarefas iniciais, incluindo a configuração de uma conta Cloud Billing, a ativação da API Cloud Run e a instalação da ferramenta de linha de comando gcloud.

Configure o faturamento do seu projeto

O Cloud Run oferece uma cota de uso sem custo financeiro, mas você ainda precisa ter uma conta Cloud Billing associada ao seu projeto do Firebase para usar ou testar o Cloud Run.

Ative a API e instale o SDK

  1. Ative a API Cloud Run no console de APIs do Google:

    1. Abra a página da API Cloud Run no console de APIs do Google.

    2. Quando solicitado, selecione seu projeto do Firebase.

    3. Clique em Ativar na página da API Cloud Run.

  2. Instale e inicialize o SDK Cloud.

  3. Verifique se a ferramenta gcloud está configurada para o projeto correto:

    gcloud config list

Etapa 1: criar o aplicativo de exemplo

O Cloud Run oferece suporte a muitas outras linguagens, além das linguagens mostradas no exemplo a seguir.

Go

  1. Crie um novo diretório chamado helloworld-go e acesse-o:

    mkdir helloworld-go
     
    cd helloworld-go

  2. Crie um novo arquivo chamado helloworld.go e adicione o seguinte código:

    package main

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

func handler(w http.ResponseWriter, r *http.Request) {
	log.Print("helloworld: received a request")
	target := os.Getenv("TARGET")
	if target == "" {
		target = "World"
	}
	fmt.Fprintf(w, "Hello %s!\n", target)
}

func main() {
	log.Print("helloworld: starting server...")

	http.HandleFunc("/", handler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("helloworld: listening on port %s", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

    helloworld.go

    Esse código cria um servidor da Web básico que detecta na porta definida pela variável de ambiente PORT.

O app está concluído, pronto para ser conteinerizado e enviado ao Artifact Registry.

Node.js

  1. Crie um novo diretório chamado helloworld-nodejs e acesse-o:

    mkdir helloworld-nodejs
     
    cd helloworld-nodejs

  2. Crie um arquivo package.json com o seguinte conteúdo:

    {
  "name": "knative-serving-helloworld",
  "version": "1.0.0",
  "description": "Simple hello world sample in Node",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "Apache-2.0",
  "dependencies": {
    "express": "^4.21.1"
  }
}

    package.json

  3. Crie um novo arquivo chamado index.js e adicione o seguinte código:

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

app.get('/', (req, res) => {
  console.log('Hello world received a request.');

  const target = process.env.TARGET || 'World';
  res.send(`Hello ${target}!\n`);
});

const port = process.env.PORT || 8080;
app.listen(port, () => {
  console.log('Hello world listening on port', port);
});

    index.js

    Esse código cria um servidor da Web básico que detecta na porta definida pela variável de ambiente PORT.

O app está concluído, pronto para ser conteinerizado e enviado ao Artifact Registry.

Python

  1. Crie um novo diretório chamado helloworld-python e acesse-o:

    mkdir helloworld-python
     
    cd helloworld-python

  2. Crie um novo arquivo chamado app.py e adicione o seguinte código:

    import os

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    target = os.environ.get('TARGET', 'World')
    return 'Hello {}!\n'.format(target)

if __name__ == "__main__":
    app.run(debug=True,host='0.0.0.0',port=int(os.environ.get('PORT', 8080)))

    app.py

    Esse código cria um servidor da Web básico que detecta na porta definida pela variável de ambiente PORT.

O app está concluído, pronto para ser conteinerizado e enviado ao Artifact Registry.

Java

  1. Instale o Java SE 8 ou um JDK posterior e o CURL.

    Observe que só precisamos fazer isso para criar o novo projeto da Web na próxima etapa. O Dockerfile, descrito posteriormente, carregará todas as dependências no contêiner.

  2. No console, crie um novo projeto da Web vazio usando cURL e, em seguida, os comandos de descompactação:

    curl https://start.spring.io/starter.zip \
    -d dependencies=web \
    -d name=helloworld \
    -d artifactId=helloworld \
    -o helloworld.zip
     
    unzip helloworld.zip

    Isso cria um projeto SpringBoot.

  3. Atualize a classe SpringBootApplication em src/main/java/com/example/helloworld/HelloworldApplication.java adicionando um @RestController para lidar com o mapeamento / e também adicione um campo @Value para fornecer a variável de ambiente TARGET:

    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("${TARGET:World}")
  String target;

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

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

    HelloworldApplication.java

    Esse código cria um servidor da Web básico que detecta na porta definida pela variável de ambiente PORT.

O app está concluído, pronto para ser conteinerizado e enviado ao Artifact Registry.

Etapa 2: conteinerizar um app e fazer upload dele para o Artifact Registry

  1. Para conteinerizar o app de amostra, basta criar um novo arquivo chamado Dockerfile no mesmo diretório dos arquivos do código-fonte. Copie o conteúdo a seguir para seu arquivo.

    Go

    # Use the official Golang image to create a build artifact.
# This is based on Debian and sets the GOPATH to /go.
FROM golang:latest AS builder

ARG TARGETOS
ARG TARGETARCH

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

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

# Install dependencies and tidy up the go.mod and go.sum files.
RUN go mod tidy

# Build the binary.
# -mod=readonly ensures immutable go.mod and go.sum in container builds.
RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -mod=readonly -v -o server

# Use the official Alpine image for a lean production container.
# https://hub.docker.com/_/alpine
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM alpine:3
RUN apk add --no-cache ca-certificates

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

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

    Dockerfile

    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 both package.json AND package-lock.json are copied.
# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./

# Install production dependencies.
RUN npm install --only=production

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

# Run the web service on container startup.
CMD [ "npm", "start" ]

    Dockerfile

    Python

    # Use the official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.7-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.
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 app:app

    Dockerfile

    Java

    # Use the official maven/Java 8 image to create a build artifact: https://hub.docker.com/_/maven
FROM maven:3.5-jdk-8-alpine 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 the Official OpenJDK image for a lean production stage of our multi-stage build.
# https://hub.docker.com/_/openjdk
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM openjdk:8-jre-alpine

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

    Dockerfile

  2. Crie a imagem do contêiner usando Cloud Build. Para isso, execute o seguinte comando no diretório que contém seu Dockerfile:

    gcloud builds submit --tag gcr.io/PROJECT_ID/helloworld

    Após a conclusão, você verá uma mensagem de SUCESSO contendo o nome da imagem
    (gcr.io/PROJECT_ID/helloworld).

A imagem do contêiner agora está armazenada no Artifact Registry e pode ser reutilizada, se desejado.

Observe que, em vez do Cloud Build, é possível usar uma versão instalada localmente do Docker para criar seu contêiner localmente.

Etapa 3: implantar a imagem do contêiner no Cloud Run

  1. Implante usando o seguinte comando:

    gcloud run deploy --image gcr.io/PROJECT_ID/helloworld

  2. Quando solicitado:

  3. Aguarde alguns instantes para que a implantação seja concluída. Em caso de sucesso, a linha de comando exibe o URL do serviço. Por exemplo: https://helloworld-RANDOM_HASH-us-central1.a.run.app

  4. Consulte o contêiner implantado. Para isso, abra o URL do serviço em um navegador da Web.

Confira na próxima etapa como acessar esse app conteinerizado a partir de um URL do Firebase Hosting de modo que ele gere conteúdo dinâmico para seu site hospedado pelo Firebase.

Etapa 4: direcionar solicitações do Hosting para o aplicativo conteinerizado

Com as regras de substituição, é possível encaminhar solicitações que correspondam a padrões específicos para um único destino.

O exemplo a seguir mostra como direcionar todas as solicitações da página /helloworld no site do Hosting para acionar a inicialização e a execução de sua instância de contêiner helloworld.

  1. Verifique se as seguintes condições foram atendidas:

    Para instruções detalhadas sobre como instalar a CLI e inicializar o Hosting, consulte o Guia de início rápido do Hosting.

  2. Abra o arquivo firebase.json.

  3. Adicione a seguinte configuração de rewrite na seção hosting:

    "hosting": {
  // ...

  // Add the "rewrites" attribute within "hosting"
  "rewrites": [ {
    "source": "/helloworld",
    "run": {
      "serviceId": "helloworld",  // "service name" (from when you deployed the container image)
      "region": "us-central1",    // optional (if omitted, default is us-central1)
      "pinTag": true              // optional (see note below)
    }
  } ]
}

  4. Implante a configuração do Hosting no site executando o seguinte comando na raiz do diretório do seu projeto:

    firebase deploy --only hosting

Seu contêiner agora pode ser acessado por meio destes URLs:

  • Subdomínios do Firebase:
    PROJECT_ID.web.app/ e PROJECT_ID.firebaseapp.com/

  • Qualquer domínio personalizado conectado:
    CUSTOM_DOMAIN/

Visite a página de configuração do Hosting para conferir mais detalhes sobre regras de substituição. Saiba mais sobre a ordem de prioridade das respostas para várias configurações do Hosting.

Testar localmente

Durante o desenvolvimento, é possível executar e testar sua imagem de contêiner localmente. Para instruções detalhadas, acesse a documentação do Cloud Run.

Próximas etapas