Search...
 

[GCP Cloud SQL] Connect to Cloud SQL for PostgreSQL from Cloud Run


ຫລັງຈາກບົດຄວາມກ່ອນໜ້ານີ້ເຮົາໄດ້ລອງຂຽນ Sample API ແລ້ວ Deploy to Google Cloud Run ກັນໄປແລ້ວ ມື້ນີ້ເຮົາມາລອງຂຽນ API ທີ່ fetch ຂໍ້ມູນມາຈາກ Database PostgreSQL ຂອງ Google Cloud SQL. (source code here)

ສິ່ງທີ່ໃຊ້:

# What is Google Cloud SQL? (ແບບສັ້ນໆ)

Fully managed relational database service for MySQL, PostgreSQL, and SQL Server with rich extension collections, configuration flags, and developer ecosystems. (reference)

Cloud SQL ເປັນບໍລິການຖານຂໍ້ມູນແບບ Relational Database ທີ່ເປັນການ Run Software ຖານຂໍ້ມູນແບບ Fully managed. ປັດຈຸບັນມີຢູ່ 3 ຄ້າຍໃຫ້ເລືອກຄື MySQL, PostgreSQL ແລະ SQL Server. (ໃນບົດຄວາມນີ້ຜູ້ຂຽນເລືອກໃຊ້ PostgreSQL)

Fully managed ແມ່ນໝາຍເຖິງທີມງານ GCP (Google Cloud Platform) ຈະເບິ່ງແຍງ ແລະ ຈັດການໃນເລື່ອງຂອງ Infrastructure ໃຫ້.

# ສ້າງ Cloud SQL Instance

ຫົວຂໍ້ນີ້ຈະແນະນຳຂັ້ນຕອນໃນການສ້າງ Cloud SQL Instance ຫຼື ເຄື່ອງທີ່ໃຊ້ Run Database ນັ້ນເອງ. ເຊິ່ງຂັ້ນຕອນດັ່ງກ່າວນີ້ແມ່ນຈະເຮັດຜ່ານ Google Cloud Console.

  1. ເປີດ Google Cloud Console
  2. ຢູ່ເມນູເບື້ອງຊ້າຍໃຫ້ເລືອກເມນູ SQL ເຊິ່ງມັນຈະຢູ່ໝວດຂອງ Database

3. ເມື່ອເຂົ້າໄປໜ້າທີ່ສະແດງລາຍການຂອງ Instance ທີ່ເຮົາມີສຳຫລັບ SQL ແລ້ວໃຫ້ເຮົາກົດ “Create Instance”

4. ຫລັງຈາກກົດປຸ່ມ “Create Instance” ລະບົບຈະໃຫ້ເຮົາເລືອກ Database Engine ທີ່ຈະໃຊ້ແນ່ນອນໃນບົດຄວາມນີ້ເຮົາຈະໃຊ້ PostgreSQL. ກົດປຸ່ມ “Choose PostgreSQL”

5. ສຳຫລັບຊ່ອງຂອງ Instance ID ໃນໜ້າ Instance info ໃຫ້ປ້ອນຊື່ທີ່ເຮົາຕ້ອງການໃສ່ໄດ້ເລີຍ

6. ໃນຊ່ອງ Password ແມ່ນເປັນການຕັ້ງລະຫັດຜ່ານສຳຫລັບ Root User.

  • ສຳຫລັບ Password Policy ຖ້າຫາກເປີດໃຊ້ ເວລາທີມີການສ້າງ User ຫຼື ປ່ຽນລະຫັດຜ່ານໃຫ້ User ຈະຕ້ອງໄດ້ໃຊ້ລະຫັດທີ່ຕັ້ງໄວ້ໃນ Password Policy ນີ້ສຳຫລັບ Verify ທຸກຄັ້ງທີ່ມີການດຳເນີນການ.

7. ໃນສ່ວນຂອງ Database version ແມ່ນເລືອກ version ຂອງ database ທີ່ຈະໃຊ້, ຜູ້ຂຽນຈະເລືອກໃຊ້ Postgrsql12.

8. Choose a configuration to start with

ກຳນົດປະເພດຂອງທີ່ເຮົາຈະໃຊ້ເຊິ່ງຈະແຍກອອກເປັນ Production, Development ແລະ Sandbox.

  • ການເລືອກໃນສ່ວນນີ້ລະບົບຈະ pre-fill ຂໍ້ມູນໃຫ້ສຳຫລັບ spec ຂອງເຄື່ອງທີ່ຈະສ້າງຕາມປະເພດທີ່ເລືອກ ແລະ ຂໍ້ມູນດັ່ງກ່າວເຮົາຍັງສາມາດໄປ Custom ໄດ້ເອງຕື່ມອີກ. ໃນສ່ວນນີ້ຜູ້ຂຽນຈະເລືອກເປັນ Sandbox ເພາະຂະໜາດນ້ອຍ.

9. Choose region and zonal availability

  • Region ແມ່ນເປັນບ່ອນທີ່ Instance ຈະຖືກສ້າງຂື້ນ
  • ສຳຫລັບ Zonal availability ແມ່ນເປັນການກຳນົດວ່າງຈະສ້າງ Instance ຂື້ນມາສະເພາະ Zone (Single Zone) ຫລື ວ່າຕ້ອງການແບບ Multi Zones. ຈະເລືອກເປັນ Signal zone.
  • ຖ້າຫາກເລືອກເປັນ Multi zones ຈະຕ້ອງໄດ້ກຳນົດວ່າຈະໃຊ້ zone ໃດເປັນຕົວຫລັກ ແລະ zone ໃດເປັນຕົວສຳຮອງ

10. Customize your instance

  • Mechine Type: ເປັນປະເພດເຄື່ອງທີ່ຈະໃຊ້ເຊິ່ງຈະມີ Shared core, Lightweight, Standard ແລະ High memory. ໃນບົດຄວາມນີ້ເຮົາຈະເລືອກເປັນປະເພດ Shared core ແລະ ເລືອກຕົວທີ່ spec ຕ່ຳສຸດ (ປະຢັດງົບ 5555).
  • Storage: ເປັນປະເພດ ແລະ ຄວາມຈຸຂອງ storage ທີ່ຈະໃຊ້ສຳຫລັບ instance ທີ່ຈະສ້າງ

ສຳຫລັບສ່ວນອື່ນໆເຊັນ Connections, Data Protection, Maintenance, Flags, Query insights ແລະ Labels ແມ່ນຈະປະເປັນຄ່າ Default ໄປກ່ອນ.

  • Connections: ເປັນບ່ອນກຳນົດຊ່ອງທາງທີ່ຈະ connect ເຂົ້າຫາ instance ທີ່ຈະສ້າງ ໂດຍ Default ຊ່ອງຂອງ Public IP ຈະຖືກເລືອກໄວ້ເພື່ອໃຫ້ສາມາດ connect ເຂົ້າໄປຫາ instance ຈາກພາຍນອກໄດ້ (ໃນບົດຄວາມນີ້ຈະໃຊ້ Google Cloud SQL Proxy )
  • Data Protection: ເປັນກຳນົດການເຮັດ Back Up, Recovery ແລະ instance deletion protection.
  • Maintenance: ເປັນບ່ອນກຳນົດໃຫ້ instance ສາມາດ restart ເຄື່ອງໄດ້ເມື່ອມີການ update. ການ update ໃນທີ່ນີ້ໝາຍເຖິງການອັບທີ່ທາງທີມງານຂອງ GCP ເປັນຄົນຈັດການ ແຕ່ສຳຫລັບການກຳນົດວ່າຈະໃຫ້ update ໄດ້ ຫລື ບໍ່ໄດ້ ນັ້ນແມ່ນເຮົາເປັນຄົນກຳນົດເອງ
  • Flags: ເປັນບ່ອນກຳນົດ Script ທີ່ເຮົາຢາກໃຫ້ instance ຂອງເຮົາ Run ເມື່ອ Start
  • Query insights: ຖ້າ enable ເຮົາຈະສາມາດເບິ່ງໄດ້ວ່າໃນ instance ຂອງເຮົາມີ queries ຫລາຍປານໃດແລ້ວທີ່ຖືກ executed ແລະ ສາມາດເບິ່ງລາຍລະອຽດຂອງ query ນັ້ນໄດ້
  • Labels: ເປັນ Key-Value pair ເພື່ອຊ່ວຍໃນການຈັດການກັບ Resource ທີ່ເຮົາໃຊ້ ສາມາດໃຊ້ເພື່ອເຮັດ filter resource ໄດ້ຈາກຊື່ຂອງ Labels ທີ່ເຮົາໄດ້ຕັ້ງໄວ້

11. ເມື່ອກຳນົດຄ່າຕາມທີ່ຕ້ອງການແລ້ວກົດ “Create Instance”

ສຳຫລັບການສ້າງແມ່ນຈະໃຊ້ເວລາໜ້ອຍໜຶ່ງປະມານ 5 ນາທີ ຫລື ຫລາຍກວ່ານັ້ນ ……………… (ຖ້າແບບໃຈເຢັນເດີ້)

ຫລັງຈາກສ້າງສຳເລັດກໍຈະໄດ້ instance ID ຕາມທີ່ໄດ້ກຳນົດໄວ້ໃນຂັ້ນຕອນການສ້າງ

12 . ກົດທີ່ “instance ID” ຂອງຜູ້ຂຽນແມ່ນຊື່ “choco” ເພື່ອສ້າງ Database ແລະ User ທີ່ຈະໃຊ້ສຳຫລັບເຮັດ connection. ເມື່ອກົດແລ້ວຈະເຂົ້າໄປທີ່ໜ້າ Overview ຂອງ instance

13. ກົດທີ່ເມນູ “Users” ແລ້ວກົດ “Add User Account”

ໃນການ Add user account ຈະມີໃຫ້ເລືອກ 2 ແບບຄື: ແບບ Built-in authentication ແລະ ແບບ Cloud IAM (ໃນບົດຄວາມນີ້ເຮົາຈະສ້າງແບບ Built-in authentication).

  • User name: ເປັນຊື່ຂອງ User ທີ່ເຮົາກຳນົດເອງ
  • Password ເປັນລະຫັດຜ່ານທີ່ຈະໃຊ້ສຳຫລັບ User ນີ້
  • ຫລັງຈາກປ້ອນຂໍ້ມູນສຳເລັດກົດ “Add”

14. ກົດທີ່ເມນູ “Database” ແລ້ວກົດ “Create Database”

  • Database Name: ກຳນົດຊື່ຂອງ Database ທີ່ຕ້ອງການ (ຂອງຜູ້ຂຽນແມ່ນຈະຕັ້ງເປັນ “choco”)
  • ກົດ “Create” ເພື່ອສ້າງ, ເມື່ອສ້າງສຳເລັດກໍຈະໄດ້ Database ທີ່ເຮົາສ້າງຂື້ນມາສະແດງໃນລາຍການຂອງ Databases

ສຳຫລັບຂັ້ນຕອນຂອງການ set up database ຢູ່ Cloud SQL ຕອນນີ້ແມ່ນພ້ອມໃຫ້ເຮົາ connect ເຂົ້າໄປໃຊ້ແລ້ວ.

# ໃຊ້ Google Cloud SQL Proxy

  1. ເປີດ terminal ທີ່ຖະນັດຂື້ນມາ
  • ຖ້າຫາກຍັງບໍ່ໄດ້ install Google Cloud SQL Proxy ສາມາດປະຕິບັດຕາມ docs ໄດ້

2. Command ໃຊ້ໃນການ connect ໄປຫາ Cloud SQL

cloud_sql_proxy -instances={instance-connection}={TCP-server} -enable_iam_login
  • instance-connection: ແມ່ນສາມາດເຂົ້າໄປເອົາຢູ່ທີ່ instance ທີ່ເຮົາສ້າງໄດ້. ໄປທີ່ເມນູ “Connections” ແລ້ວ copy ເອົາ connection name

ເຮົາຈະໄດ້ connection name “phuangpheth:asia-southeast1:choco”

  • TCP-server: ເປີດ TCP connection ຢູ່ເຄື່ອງ Local e.g., “tcp:0.0.0.0:port”
  • -enable_iam_login: enable ໃຫ້ database user authentication ດ້ວຍ Cloud SQL’s IAM DB Authentication (Postgres only).

ສາມາດເບິ່ງຂໍ້ມູນເພີ່ມຕື່ມສຳຫລັບການໃຊ້ cloud_sql_proxy ໄດ້ໂດຍການເພີ່ມ “ — help”

ເມື່ອປະກອບຂໍ້ມູນສຳເລັດຈະໄດ້ Command ດັ່ງນີ້:

cloud_sql_proxy -instances=phuangpheth:asia-southeast1:choco=tcp:127.0.0.1:5432 -enable_iam_login

3. ລອງເອົາ Command ມາ Run ເພື່ອທົດສອບວ່າເຮົາສາມາດ connect ໄປຫາ Cloud SQL ຂອງເຮົາໄດ້ແທ້ບໍ

ເຢ້ connect ໄດ້ແລ້ວວວວວ

#Note: ຕ້ອງໄດ້ Run command ນີ້ປະໄວ້ຖ້າເຮົາຕ້ອງການທີ່ຈະ connect ໄປ Cloud SQL. ເມື່ອໃດທີ່ເຮົາປິດ ເຮົາຈະບໍ່ສາມາດໃຊ້ Cloud SQL ຢູ່ເຄື່ອງ Local ຂອງເຮົາໄດ້

ຫລັງຈາກ Run Command ເພື່ອສ້າງ connection ໄວ້ແລ້ວ ເຮົາມາໃຊ້ User ທີ່ເຮົາສ້າງໄວ້ເພື່ອ Login ເຂົ້າໄປໃຊ້ງານ. ຈະໃຊ້ psql ສຳຫລັບ interact with Postgres

psql -U {username}-p 5432 -d {databaseName} -W
  • username: ແມ່ນ user name ທີ່ໄດ້ຈາກຂັ້ນຕອນ Add User Account
  • databaseName: ແມ່ນ database name ທີ່ໄດ້ຈາກຂັ້ນຕອນ Create Database

ຈະໄດ້ command ດັ່ງນີ້:

psql -U choco -p 5432 -d choco -W

ເມື່ອກົດ “enter” ມັນຈະໃຫ້ເຮົາປ້ອນລະຫັດຜ່ານ (ລະຫັດຜ່ານທີ່ໄດ້ສ້າງໃນຂັ້ນຕອນ Add User Account).

ເຢ້ໆ login ເຂົ້າໃຊ້ database ທີ່ເຮົາສ້າງໄວ້ໄດ້ແລ້ວວວວ

#ໃຊ້ Migration CLI

Migration CLI ໃຊ້ສຳຫລັບເຮັດ migrate database ແບບ Step Up ຫລື Step Down ໄດ້ເມື່ອປ່ຽນ Schema (More info)

  1. Command ເບື່ອງຕົ້ນ ແລະ ອະທິບາຍການໃຊ້ງານ(ແບບສັ້ນໆ)
  • Command ໃນການສ້າງ files
migrate create -dir {directory} -seq -ext sql init

directory ເປັນບ່ອນທີ່ຈະໃຫ້ migrate ເກັບ files ໄວ້

ຫລັງຈາກທີ່ Run command ດ້ານເທີງຕົວ migrate ຈະສ້າງ Folder ຕາມທີ່ເຮົາໄດ້ກຳນົດໄວ້ພ້ອມທັງ files ທີ່ເປັນ Up ແລະ Down

  • Up ເປັນ file ທີ່ໃຊ້ສຳຫລັບ upgrade ໃຫ້ database ເປັນ version ຖັດໄປ
  • Down ເປັນ file ທີ່ໃຊ້ສຳຫລັບ downgrade ໃຫ້ database ເປັນ version ກ່ອນຫນ້າທີ່ file ຖືກສ້າງຂື້ນ

ຕົວຢ່າງ: ປັດຈຸຸບັນໃນ database ມີ table ທີ່ຊື່ວ່າ users ເຊິ່ງ version ປັດຈຸບັນມີ columns ດັ່ງນີ້:

CREATE TABLE users(
  id TEXT NOT NULL PRIMARY KEY,
  display_name TEXT NOT NULL
);

ສຳຫລັບການແກ້ໄຂແມ່ນຈະເພີ່ມ columns email ປະເພດຂໍ້ມູນເປັນ text ເຂົ້າ table users

  • Run migrate command
migrate create -dir {directory} -seq -ext sql init
  • ສຳຫລັບ file up
ALTER TABLE users
ADD email TEXT NOT NULL;
  • ສຳຫລັບ file down
ALTER TABLE users
DROP COLUMN email;

ຈະເຫັນໄດ້ວ່າ file up ໃຊ້ເພີ່ມ column email ເຂົ້າ table users. ໃນສ່ວນຂອງ file down ໃຊ້ລຶບ column email ອອກຈາກ table users ເຊິ່ງເປັນ version ປັດຈຸບັນກ່ອນທີ່ file up ຈະຖືກ execute.

  • Command ສຳຫລັບ run up ຫລື down version
migrate -path {directory} -database "{databaseURL}" -verbose up/down

– databaseURL: url ຂອງ database ທີ່ຕ້ອງການ migrate ຂໍ້ມູນ (ຕ້ອງໄດ້ໃສ່ຊື່ຂອງ database ພ້ອມ)
– directory: ທີ່ຢູ່ຂອງ files migration (ໃສ່ຮອດແຕ່ Folder)
– up/down: ຖ້າໃຊ້ up ຕົວ migrate ຈະ execute file up, ຖ້າໃຊ້ down ຕົວ migrate ຈະ execute file down

ຕົວຢ່າງ command ໃນການ execute file up:

migrate -path migrations -database "postgresql://root:[email protected]:5455/choco?sslmode=disable" -verbose up

ໃນຕົວຢ່າງແມ່ນຈະເຮັດ migrate ຈາກ folder ທີ່ຊື່ວ່າ migrations ເຂົ້າ database.
ເຊິ່ງແຍກຂໍ້ມູນຈາກ command ອອກມາກໍຈະໄດ້ດັ່ງນີ້:

– driver: postgresql
– host: 127.0.0.1 (localhost ນັ້ນເອງ)
– port: 5455
– user: root
– password: 101023
– database: choco

2. ສ້າງ Table products ດ້ວຍ Migrate CLI

  • Run command ເພື່ອໃຫ້ migrate ສ້າງ files ໄວ້ໃນ folder migrations
migrate create -dir migrations -seq -ext sql init

ຈະໄດ້ folder ຊື່ migrations ແລະ files ດັ່ງນີ້:

  • file up ມີ code ດັ່ງນີ້
CREATE TABLE products(
  id TEXT NOT NULL PRIMARY KEY,
  display_name TEXT NOT NULL,
  currency TEXT NOT NULL,
  price DECIMAL(18,2) NOT NULL,
  qty DECIMAL(10,2) NOT NULL,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);
  • file down ມີ code ດັ່ງນີ້
DROP TABLE IF EXISTS products;
  • Run migration up ເພື່ອເລີ່ມ migrate
migrate -path directory -database "driverName://user:password@host:port/db_name?sslmode=disable" -verbose up

migrate ສຳເລັດຈະໄດ້

ເມື່ອເຂົ້າໄປກວດເບິ່ງໃນ database ທີ່ເຮົາ migrate ກໍຈະເຫັນ table products ແລະ schema_migrations(ເປັນ table ທີ່ໃຊ້ສຳຫລັບຕິດຕາມວ່າປັດຈຸບັນ database ຂອງເຮົາໄດ້ migrate ຮອດ version ໃດແລ້ວ)

#Update Golang API ໃຫ້ດຶງຂໍ້ມູນຈາກ table products ມາເປັນ Response

1 file main.go

package main

import (
 "context"
 "database/sql"
 "fmt"
 "log"
 "net/http"
 "os"
 "os/signal"
 "time"

 "github.com/labstack/echo/v4"
 "github.com/labstack/echo/v4/middleware"
 "github.com/shopspring/decimal"

 _ "github.com/lib/pq"
)

func getEnv(key, fallback string) string {
 if value := os.Getenv(key); value != "" {
  return value
 }
 return fallback
}

func failOnError(err error, msg string) {
 if err != nil {
  fmt.Println(msg, err)
  os.Exit(1)
 }
}

func main() {
 ctx := context.Background()
 dbHost := os.Getenv("DB_HOST")
 dbPort := os.Getenv("DB_PORT")
 dbUser := os.Getenv("DB_USER")
 dbPassword := os.Getenv("DB_PASSWORD")
 dbName := os.Getenv("DB_NAME")
 dbURL := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable", dbHost, dbPort, dbUser, dbPassword, dbName)

 db, err := sql.Open("postgres", dbURL)
 failOnError(err, "failed to open database")
 defer func() {
  err := db.Close()
  failOnError(err, "failed to close database")
 }()

 h := &handler{db: db}
 e := echo.New()

 e.Use(middleware.Logger())
 e.Use(middleware.Recover())

 e.GET("/", func(c echo.Context) error {
  return c.JSON(http.StatusOK, echo.Map{
   "message": "Hello, this is a message from Golang running on CloudRun.",
  })
 })
 e.GET("/products", h.ListProducts)

 errCh := make(chan error, 1)
 go func() {
  errCh <- e.Start(fmt.Sprintf(":%s", getEnv("PORT", "3001")))
 }()

 ctx, cancel := signal.NotifyContext(ctx, os.Kill, os.Interrupt)
 defer cancel()

 select {
 case err := <-errCh:
  if err != nil && err != http.ErrServerClosed {
   log.Fatal("failed to start server")
  }
  log.Println("server shutdown gracefully")

 case <-ctx.Done():
  ctx, cancel := context.WithTimeout(ctx, time.Second*15)
  defer cancel()

  log.Println("shutting down server...")
  if err := e.Shutdown(ctx); err != nil {
   log.Fatal("failed to shutdown server")
  }
  log.Println("shutdown server gracefully")
 }
}

type handler struct {
 db *sql.DB
}

type Product struct {
 ID        string          `json:"id"`
 Name      string          `json:"displayName"`
 Currency  string          `json:"currency"`
 Price     decimal.Decimal `json:"price"`
 Quantity  decimal.Decimal `json:"quantity"`
 CreatedAt time.Time       `json:"createdAt"`
 UpdatedAt time.Time       `json:"updatedAt"`
}

func (h *handler) ListProducts(c echo.Context) error {
 products, err := listProducts(c.Request().Context(), h.db)
 if err != nil {
  return err
 }

 return c.JSON(http.StatusOK, echo.Map{
  "products": products,
 })
}

func listProducts(ctx context.Context, db *sql.DB) ([]Product, error) {
 query := `SELECT id, display_name, currency, price, qty, created_at, updated_at FROM products`

 rows, err := db.QueryContext(ctx, query)
 if err != nil {
  return nil, fmt.Errorf("db.QueryContext(): %w", err)
 }

 products := make([]Product, 0)
 for rows.Next() {
  var p Product
  if err := rows.Scan(&p.ID, &p.Name, &p.Currency, &p.Price, &p.Quantity, &p.CreatedAt, &p.UpdatedAt); err != nil {
   return nil, fmt.Errorf("rows.Scan(): %w", err)
  }
  products = append(products, p)
 }
 return products, nil
}

2. file Dockerfile

# Start from golang base image as building stage
FROM golang:1.19-alpine as builder

# Set necessary environment variables needed for our image
ENV GO111MODULE=on CGO_ENABLED=0 GOOS=linux GOARCH=amd64

# Set the current working directory inside the container
WORKDIR /build

# Copy and download dependency using go mod
COPY go.mod .
COPY go.sum .
RUN apk add --no-cache ca-certificates git tzdata && \
  go mod tidy

# Copy the code into the container
COPY . .

# Build the Go application
RUN go build -ldflags "-s -w -extldflags '-static'" -installsuffix cgo -o /bin/service main.go

# Use alpine image as runtime
FROM alpine:3.16 as release

COPY --from=builder /usr/share/zoneinfo /usr/share/zoneinfo
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=builder /bin/service /bin/service

# Command to run 
ENTRYPOINT ["/bin/service"]

3. Build Golang API ດ້ວຍ Docker ເພື່ອກຽມ Deploy to Google Cloud Run (ສາມາດເບິ່ງລາຍລະອຽດຂອງການ build ໄດ້ທີ່ ບົດຄວາມກ່ອນຫນ້ານີ້)


docker build -t asia-southeast1-docker.pkg.dev/phuangpheth/hal0kiity/api:v1.0.0 .

4. Push Docker Image to Google Cloud Artifact Registory

docker push asia-southeast1-docker.pkg.dev/phuangpheth/hal0kiity/api:v1.0.0

#Deploy Golang API to Google Cloud Run

  1. ເປີດ Google Cloud Console ແລ້ວໄປທີ່ເມນູ Cloud Run
  2. ກົດທີ່ຊື່ຂອງ service ທີ່ຈະໃຊ້ deploy (ສາມາດເບິ່ງຂັ້ນຕອນລະອຽດໄດ້ຈາກ ບົດຄວາມກ່ອນຫນ້ານີ້)
  3. ກົດປຸ່ມ “Edit & Deploy Revision”
  4. ສຳຫລັບ Container Image ໃຫ້ກົດ “Select” ເພື່ອເລືອກ Container Image ທີ່ຈະໃຊ້ deploy

ເມື່ອເລືອກ Container Image ທີ່ຕ້ອງການແລ້ວໃຫ້ກົດ “Select”

5. ເພີ່ມ Environment Variables ຕາມທີ່ໄດ້ກຳນົດໄວ້ໃນ API ທີ່ສ້າງ ກໍຈະເປັນ environment ຂອງການ connect ໄປຫາ database ນັ້ນເອງ

  • DB_HOST ແມ່ນເອົາຈາກ Cloud SQL instance ໂດຍເຂົ້າໄປທີ່ເມນູ “SQL” ແລ້ວກົດເລືອກ instance name ທີ່ຕ້ອງການ ໃນຫນ້າ Overview ຈະເຫັນ ສ່ວນຂອງ “Connect to instance” ໃຫ້ກົດ copy ເອົາ “Connection name”

ເມື່ອໄດ້ connection name ມາແລ້ວໃຫ້ເອົາມາຕໍ່ກັບ “/cloudsql/{connectionName}” ຈະໄດ້ DB_HOST ດັ່ງນີ້

/cloudsql/phuangpheth:asia-southeast1:choco

  • ສຳຫລັບ DB_PASSWORD ຈະຕັ້ງເປັນ Secrets ເພື່ອປ້ອງການບໍ່ໃຫ້ທຸກສາມາດເຫັນ Password ນີ້ໄດ້

6. ເລືອກ Cloud SQL instance ໃຫ້ກັບ Cloud SQL connections ເພື່ອໃຫ້ Cloud Run ສາມາດ connect ໄປຫາໄດ້

7. ເມື່ອສຳເລັດກົດ “Deploy”

ຫລັງຈາກ Deploy ສຳເລັດເຮົາກໍຈະໄດ້ URL ສຳຫລັບ API ຂອງເຮົາກັນແລ້ວ.

ລອງ Request ໄປຫາ API ຂອງເຮົາລອງເບິ່ງວ່າມັນຈະ Work ຫລືບໍ່

ເຢ້ໆ It is working well…… ຈົບແລ້ວໄດ໋ 555555

Support by:

ໜ້າຫຼັກ

Google Cloud Run Google Cloud Sql Golang Postresql Backend Dev

ຂຽນໂດຍ: Pao Phouminith

Related Posts ...