Menghubungkan ke instance Redis dari layanan Cloud Run

Anda dapat terhubung ke instance Redis dari Cloud Run menggunakan Traffic keluar VPC Langsung (Pratinjau) atau Akses VPC Serverless.

Penyiapan

Jika sudah menginstal Google Cloud CLI dan telah membuat instance Redis, Anda dapat melewati langkah-langkah ini.

Instal gcloud CLI dan lakukan inisialisasi:
```
gcloud init
```
Ikuti Panduan Memulai untuk membuat instance Redis. Catat zona, alamat IP, dan port instance Redis.

Menyiapkan traffic keluar jaringan VPC untuk konfigurasi

Agar terhubung ke instance Redis, layanan Cloud Run Anda memerlukan akses ke jaringan VPC resmi instance Redis. Untuk mengaktifkan akses ini, Anda memerlukan traffic keluar VPC Langsung atau konektor Akses VPC Serverless. Bandingkan kedua metode traffic keluar jaringan tersebut.

Temukan nama jaringan yang diizinkan instance Redis Anda dengan menjalankan perintah berikut:
```
gcloud redis instances describe INSTANCE_ID --region REGION --format "value(authorizedNetwork)"
```
Catat nama jaringannya.
Jika Anda menggunakan Akses VPC Serverless, buat konektor. Pastikan untuk menggunakan region dan jaringan VPC yang sama dengan yang digunakan oleh instance Redis. Catat nama konektornya.

Contoh aplikasi

Contoh aplikasi server HTTP ini membuat koneksi ke instance Redis dari layanan Cloud Run.

Clone repositori untuk bahasa pemrograman yang Anda pilih dan buka folder yang berisi kode contoh:

Go

git clone https://github.com/GoogleCloudPlatform/golang-samples
cd golang-samples/memorystore/redis

Node.js

git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples
cd nodejs-docs-samples/memorystore/redis

Python

git clone https://github.com/GoogleCloudPlatform/python-docs-samples
cd python-docs-samples/memorystore/redis

Aplikasi contoh ini menambahkan penghitung Redis setiap kali endpoint / diakses.

Go

Aplikasi ini menggunakan klien github.com/gomodule/redigo/redis. Instal paket tersebut dengan menjalankan perintah berikut:

go get github.com/gomodule/redigo/redis


// Command redis is a basic app that connects to a managed Redis instance.
package main

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

	"github.com/gomodule/redigo/redis"
)

var redisPool *redis.Pool

func incrementHandler(w http.ResponseWriter, r *http.Request) {
	conn := redisPool.Get()
	defer conn.Close()

	counter, err := redis.Int(conn.Do("INCR", "visits"))
	if err != nil {
		http.Error(w, "Error incrementing visitor counter", http.StatusInternalServerError)
		return
	}
	fmt.Fprintf(w, "Visitor number: %d", counter)
}

func main() {
	redisHost := os.Getenv("REDISHOST")
	redisPort := os.Getenv("REDISPORT")
	redisAddr := fmt.Sprintf("%s:%s", redisHost, redisPort)

	const maxConnections = 10
	redisPool = &redis.Pool{
		MaxIdle: maxConnections,
		Dial:    func() (redis.Conn, error) { return redis.Dial("tcp", redisAddr) },
	}

	http.HandleFunc("/", incrementHandler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

Node.js

Aplikasi ini menggunakan modul redis.

{
  "name": "memorystore-redis",
  "description": "An example of using Memorystore(Redis) with Node.js",
  "version": "0.0.1",
  "private": true,
  "license": "Apache Version 2.0",
  "author": "Google Inc.",
  "engines": {
    "node": ">=16.0.0"
  },
  "dependencies": {
    "redis": "^4.0.0"
  }
}

'use strict';
const http = require('http');
const redis = require('redis');

const REDISHOST = process.env.REDISHOST || 'localhost';
const REDISPORT = process.env.REDISPORT || 6379;

const client = redis.createClient(REDISPORT, REDISHOST);
client.on('error', err => console.error('ERR:REDIS:', err));

// create a server
http
  .createServer((req, res) => {
    // increment the visit counter
    client.incr('visits', (err, reply) => {
      if (err) {
        console.log(err);
        res.status(500).send(err.message);
        return;
      }
      res.writeHead(200, {'Content-Type': 'text/plain'});
      res.end(`Visitor number: ${reply}\n`);
    });
  })
  .listen(8080);

Python

Aplikasi ini menggunakan Flask untuk penayangan web dan paket redis-py untuk berkomunikasi dengan instance Redis.

Flask==3.0.0
gunicorn==22.0.0
redis==5.0.1
Werkzeug==3.0.1

import logging
import os

from flask import Flask
import redis

app = Flask(__name__)

redis_host = os.environ.get("REDISHOST", "localhost")
redis_port = int(os.environ.get("REDISPORT", 6379))
redis_client = redis.StrictRedis(host=redis_host, port=redis_port)

@app.route("/")
def index():
    value = redis_client.incr("counter", 1)
    return f"Visitor number: {value}"

@app.errorhandler(500)
def server_error(e):
    logging.exception("An error occurred during a request.")
    return (
        """
    An internal error occurred: <pre>{}</pre>
    See logs for full stacktrace.
    """.format(
            e
        ),
        500,
    )

if __name__ == "__main__":
    # This is used when running locally. Gunicorn is used to run the
    # application on Google App Engine and Cloud Run.
    # See entrypoint in app.yaml or Dockerfile.
    app.run(host="127.0.0.1", port=8080, debug=True)

Men-deploy aplikasi ke Cloud Run

Untuk men-deploy aplikasi:

Salin Dockerfile ke direktori sumber:
```
cp cloud_run_deployment/Dockerfile .
```
Bangun image container menggunakan Cloud Build dengan perintah berikut:
```
gcloud builds submit --tag gcr.io/PROJECT_ID/visit-count
```
Men-deploy container ke Cloud Run.
- Jika Anda menggunakan traffic keluar VPC Langsung, jalankan perintah berikut:
```
gcloud run deploy \
--image gcr.io/PROJECT_ID/visit-count \
--platform managed \
--allow-unauthenticated \
--region REGION \
--network NETWORK \
--subnet SUBNET \
--set-env-vars REDISHOST=REDIS_IP,REDISPORT=REDIS_PORT
```
  dengan:
  - PROJECT_ID adalah ID project Google Cloud Anda.
  - REGION adalah region tempat instance Redis Anda berada.
  - NETWORK adalah nama jaringan VPC terotorisasi tempat instance Redis Anda terpasang.
  - SUBNET adalah nama subnet Anda. Subnet harus /26 atau lebih besar. Traffic keluar VPC langsung mendukung rentang IPv4 RFC 1918, RFC 6598, dan Kelas E.
  - REDIS_IP dan REDIS_PORT adalah alamat IP dan nomor port instance Redis Anda.
- Jika Anda menggunakan konektor Akses VPC Serverless, jalankan perintah berikut:
```
gcloud run deploy \
--image gcr.io/PROJECT_ID/visit-count \
--platform managed \
--allow-unauthenticated \
--region REGION \
--vpc-connector CONNECTOR_NAME \
--set-env-vars REDISHOST=REDIS_IP,REDISPORT=REDIS_PORT
```
  dengan:
  - PROJECT_ID adalah ID project Google Cloud Anda.
  - REGION adalah region tempat konektor Akses VPC Serverless dan instance Redis Anda berada.
  - CONNECTOR_NAME adalah nama konektor Anda.
  - REDIS_IP dan REDIS_PORT adalah alamat IP dan nomor port instance Redis Anda.

Setelah deployment berhasil diselesaikan, command line akan menampilkan URL layanan Cloud Run Anda. Buka URL ini di browser web (atau gunakan alat seperti curl) dan lihat jumlah instance Redis Anda meningkat setiap kali layanan dikunjungi.