Cloud Run ile dinamik içerik sunma ve mikro hizmetler barındırma

Dinamik içeriğinizi oluşturup sunmak veya REST API'leri mikro hizmet olarak oluşturmak için Cloud Run ile Firebase Hosting'i eşleyin.

Cloud Run'ı kullanarak container görüntüsünde paketlenmiş bir uygulamayı dağıtabilirsiniz. Ardından, Firebase Hosting kullanarak HTTPS isteklerini, container mimarisine alınmış uygulamanızı tetikleyecek şekilde yönlendirebilirsiniz.

  • Cloud Run, birden fazla dili (Go, Node.js, Python ve Java dahil) destekleyerek istediğiniz programlama dilini ve çerçeveyi kullanma esnekliği sunar.
  • Cloud Run, gelen istekleri karşılamak için container görüntünüzü otomatik ve yatay olarak ölçeklendirir, talep azaldığında ise ölçeği küçültür.
  • Yalnızca istek işleme sırasında tüketilen CPU, bellek ve ağ için ödeme yaparsınız.

Firebase Hosting ile entegre edilmiş Cloud Run için örnek kullanım alanları ve örnekler için sunucusuz mimariye genel bakış sayfamızı ziyaret edin.


Bu kılavuzda aşağıdakileri nasıl yapacağınız açıklanmaktadır:

  1. Basit bir Hello World uygulaması yazma
  2. Uygulamayı container mimarisine alma ve Artifact Registry'a yükleme
  3. Container görüntüsünü Cloud Run hizmetine dağıtma
  4. Hosting isteklerini container mimarisine alınmış uygulamanıza yönlendirme

Dinamik içerik sunma performansını artırmak için isteğe bağlı olarak önbellek ayarlarınızı düzenleyebilirsiniz.

Başlamadan önce

Cloud Run aracını kullanmadan önce Cloud Billing hesabı oluşturma, Cloud Run API'sini etkinleştirme ve gcloud komut satırı aracını yükleme gibi bazı ilk görevleri tamamlamanız gerekir.

Projeniz için faturalandırmayı ayarlayın

Cloud Run, ücretsiz kullanım kotası sunar ancak Cloud Run ürününü kullanmak veya denemek için Firebase projenizle ilişkili bir Cloud Billing hesabınızın olması gerekir.

API'yi etkinleştirme ve SDK'yı yükleme

  1. Google API Konsolu'nda Cloud Run API'yi etkinleştirin:

    1. Google API Konsolu'nda Cloud Run API sayfasını açın.

    2. İstendiğinde Firebase projenizi seçin.

    3. Cloud Run API sayfasında Etkinleştir'i tıklayın.

  2. Cloud SDK'yı yükleyip ilk kullanıma hazırlayın.

  3. gcloud aracının doğru proje için yapılandırıldığından emin olun:

    gcloud config list

1. adım: Örnek uygulamayı yazın

Cloud Run, aşağıdaki örnekte gösterilen dillerin yanı sıra birçok dili daha destekler.

Go

  1. helloworld-go adlı yeni bir dizin oluşturun ve bu dizine geçin:

    mkdir helloworld-go
     
    cd helloworld-go
    1. helloworld.go adlı yeni bir dosya oluşturun ve aşağıdaki kodu ekleyin:
    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))
}

    Bu kod, PORT ortam değişkeni tarafından tanımlanan bağlantı noktasını dinleyen temel bir web sunucusu oluşturur.

Uygulamanız tamamlandı ve container'a yerleştirilip Artifact Registry platformuna yüklenmeye hazır.

Node.js

  1. helloworld-nodejs adlı yeni bir dizin oluşturun ve dizini bu dizinle değiştirin:

    mkdir helloworld-nodejs
     
    cd helloworld-nodejs

  2. Aşağıdaki içeriklerle bir package.json dosyası oluşturun:

    {
  "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.22.1"
  }
}

  3. index.js adlı yeni bir dosya oluşturun ve aşağıdaki kodu ekleyin:

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

    Bu kod, PORT ortam değişkeni tarafından tanımlanan bağlantı noktasını dinleyen temel bir web sunucusu oluşturur.

Uygulamanız tamamlandı ve container'a yerleştirilip Artifact Registry platformuna yüklenmeye hazır.

Python

  1. helloworld-python adlı yeni bir dizin oluşturun ve bu dizine geçin:

    mkdir helloworld-python
     
    cd helloworld-python

  2. app.py adlı yeni bir dosya oluşturun ve aşağıdaki kodu ekleyin:

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

    Bu kod, PORT ortam değişkeni tarafından tanımlanan bağlantı noktasını dinleyen temel bir web sunucusu oluşturur.

Uygulamanız tamamlandı ve container'a yerleştirilip Artifact Registry platformuna yüklenmeye hazır.

Java

  1. Java SE 8 veya sonraki bir JDK sürümünü ve CURL'ü yükleyin.

    Bunu yalnızca bir sonraki adımda yeni web projesini oluşturmak için yapmamız gerektiğini unutmayın. Daha sonra açıklanacak olan Dockerfile, tüm bağımlılıkları kapsayıcıya yükler.

  2. Konsoldan cURL ve ardından unzip komutlarını kullanarak yeni bir boş web projesi oluşturun:

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

    Bu komut bir SpringBoot projesi oluşturur.

  3. / eşlemesini işlemek için bir @RestController ekleyerek src/main/java/com/example/helloworld/HelloworldApplication.java içindeki SpringBootApplication sınıfını güncelleyin ve TARGET ortam değişkenini sağlamak için bir @Value alanı ekleyin:

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

    Bu kod, PORT ortam değişkeni tarafından tanımlanan bağlantı noktasını dinleyen temel bir web sunucusu oluşturur.

Uygulamanız tamamlandı ve container'a yerleştirilip Artifact Registry platformuna yüklenmeye hazır.

2. adım: Bir uygulamayı container'a yerleştirip Artifact Registry platformuna yükleyin.

  1. Kaynak dosyalarla aynı dizinde Dockerfile adlı yeni bir dosya oluşturarak örnek uygulamayı container'a yerleştirin. Aşağıdaki içeriği dosyanıza kopyalayın.

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

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

    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

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

  2. Dockerfile'ınızı içeren dizinden aşağıdaki komutu çalıştırarak Cloud Build ile container görüntünüzü oluşturun:

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

    İşlem başarılı olursa resim adını içeren bir BAŞARILI mesajı görürsünüz
    (gcr.io/PROJECT_ID/helloworld).

Container görüntüsü artık Artifact Registry içinde depolanır ve istenirse yeniden kullanılabilir.

Cloud Build yerine Docker'ın yerel olarak yüklenmiş bir sürümünü kullanarak container'ınızı yerel olarak derleyebileceğinizi unutmayın.

3. adım: Kapsayıcı görüntüsünü Cloud Run hizmetine dağıtın.

  1. Aşağıdaki komutu kullanarak dağıtın:

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

  2. İstendiğinde:

  3. Dağıtımın tamamlanması için biraz bekleyin. İşlem başarılı olursa komut satırında hizmet URL'si gösterilir. Örneğin: https://helloworld-RANDOM_HASH-us-central1.a.run.app

  4. Dağıtılan kapsayıcınızı ziyaret etmek için hizmet URL'sini bir web tarayıcısında açın.

Bir sonraki adımda, Firebase tarafından barındırılan siteniz için dinamik içerik oluşturabilmesi amacıyla bu container mimarisine alınmış uygulamaya bir Firebase Hosting URL'sinden nasıl erişeceğiniz açıklanmaktadır.

4. adım: Barındırma isteklerini container mimarisine alınmış uygulamanıza yönlendirme

Yeniden yazma kuralları ile belirli kalıplarla eşleşen istekleri tek bir hedefe yönlendirebilirsiniz.

Aşağıdaki örnekte, Hosting sitenizdeki /helloworld sayfasından gelen tüm isteklerin, helloworld kapsayıcı örneğinizin başlatılmasını ve çalıştırılmasını tetikleyecek şekilde nasıl yönlendirileceği gösterilmektedir.

  1. Aşağıdaki koşulların karşılandığından emin olun:

    CLI'yı yükleme ve Hosting'ı başlatma hakkında ayrıntılı talimatlar için Hosting için Başlangıç kılavuzuna bakın.

  2. firebase.json dosyanızı açın.

  3. hosting bölümünün altına aşağıdaki rewrite yapılandırmasını ekleyin:

    "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. Proje dizininizin kökünden aşağıdaki komutu çalıştırarak barındırma yapılandırmanızı sitenize dağıtın:

    firebase deploy --only hosting

Kapsayıcınıza artık aşağıdaki URL'ler üzerinden erişilebilir:

  • Firebase alt alan adlarınız:
    PROJECT_ID.web.app/ ve PROJECT_ID.firebaseapp.com/

  • Bağlı özel alan adları:
    CUSTOM_DOMAIN/

Yeniden yazma kuralları hakkında daha fazla bilgi edinmek için Hosting yapılandırma sayfasını ziyaret edin. Ayrıca çeşitli Hosting yapılandırmaları için yanıtların öncelik sırası hakkında bilgi edinebilirsiniz.

Yerel olarak test etme

Geliştirme sırasında container görüntünüzü yerel olarak çalıştırıp test edebilirsiniz. Ayrıntılı talimatlar için Cloud Run belgelerini inceleyin.

Sonraki adımlar