สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

การตรวจสอบระยะเวลาทำงานเกี่ยวข้องกับการตรวจสอบความพร้อมใช้งานของเว็บไซต์, API และเซิร์ฟเวอร์ จอภาพจะตรวจสอบจุดปลายที่กำหนดภายในช่วงเวลาที่กำหนดเพื่อพิจารณาว่าจุดปลายนั้นพร้อมใช้งานหรือไม่ เป้าหมายคือการบรรลุระดับความพร้อมใช้งานตามสัญญา ตามที่ระบุไว้ใน SLA ของระบบ และกำหนดความแตกต่างเมื่อไม่ตรงตามสัญญา

ในบทความนี้ เราจะสร้างระบบตรวจสอบสถานะการออนไลน์โดยใช้ Prometheus blackbox_exporter แม้ว่าการสร้างระบบตรวจสอบ HTTP แบบกำหนดเองอาจไม่ใช่เรื่องง่าย แต่การสร้าง Wrapper รอบๆ ผู้ส่งออกช่วยให้เราเข้าถึงเทคนิคการตรวจสอบอื่นๆ มากมาย และตรวจสอบองค์ประกอบอื่นๆ ของระบบได้อย่างรวดเร็ว

บทความนี้ครอบคลุมถึงการใช้เทคโนโลยีหลายอย่าง และฉันจะอธิบายแต่ละองค์ประกอบก่อนที่จะลงลึกในรายละเอียดของระบบเวลาทำงาน

Google Compute Engine (GCE) คืออะไร

Compute Engine คือบริการการประมวลผลแบบคลาวด์ของ Google ที่คล้ายกับข้อเสนอการประมวลผล EC2 ของ AWS GCE มีความปลอดภัยและปรับแต่งได้มากพอที่จะรองรับปริมาณงานต่างๆ ตั้งแต่เครื่องขนาดเล็ก (รองรับสูงสุด 32 vCPU และหน่วยความจำ 128 GB) ไปจนถึงเครื่องมาตรฐาน (รองรับ vCPU สูงสุด 224 และหน่วยความจำ 896 GB) และเครื่องระดับไฮเอนด์อื่นๆ สำหรับปริมาณงานที่เข้มข้น ใช้คอมพิวเตอร์ตามความต้องการเพื่อปรับขนาดตามความต้องการของคุณต่อครั้ง

GCE รองรับกลไกการปรับใช้ที่แตกต่างกันสำหรับการปรับใช้แอป รวมถึงคอนเทนเนอร์ เทมเพลตอินสแตนซ์ และกลุ่มอินสแตนซ์ที่มีการจัดการ สำหรับวัตถุประสงค์ของบทความนี้ เราจะรวมโปรแกรมตรวจสอบสถานะการออนไลน์ของ Ruby ไว้ในคอนเทนเนอร์นักเทียบท่าสำหรับการปรับใช้

Cloud Storage คืออะไร

Google Cloud Storage เป็นบริการจัดเก็บอ็อบเจ็กต์ที่มีความพร้อมใช้งานสูง ซึ่งคล้ายกับบริการ S3 ของ AWS Cloud Storage มีคุณสมบัติการจัดเก็บข้อมูลมากมายที่เปิดใช้งานกรณีการใช้งานต่างๆ สำหรับแอพสมัยใหม่ ในการเริ่มต้นใช้งาน Cloud Storage ใน Ruby เราจะใช้ google-cloud-storage อัญมณีสำหรับตรวจสอบสิทธิ์ รวมถึงการอัปโหลดและดาวน์โหลดไฟล์จาก Cloud Storage:

require 'google/cloud/storage'

def upload_file bucket_name:, file_path:, file_name: nil
 storage = Google::Cloud::Storage.new
 bucket = storage.bucket bucket_name

 file = bucket.create_file file_path, file_name
end

def download_file bucket_name: file_path, file_name: nil
 storage = Google::Cloud::Storage.new
 bucket = storage.bucket bucket_name
 file = bucket.file file_name

 file.download file_path
end

หมายเหตุ :คุณต้องตั้งค่า GOOGLE_APPLICATION_CREDENTIALS ในสภาพแวดล้อมของคุณเพื่อชี้ไปที่รหัสบัญชีบริการที่ถูกต้อง เจมของไคลเอ็นต์ Google ทั้งหมดค้นหาตัวแปรสภาพแวดล้อมนี้เพื่อการอนุญาต ไม่เช่นนั้น คุณจะต้องส่งพารามิเตอร์เฉพาะการตรวจสอบสิทธิ์ไปยัง Google::Cloud::Storage.new . อย่างไรก็ตาม หากแอปของคุณทำงานใน GCE VM แสดงว่ามีการตั้งค่านี้ในสภาพแวดล้อมแล้ว

Cloud PubSub คืออะไร

Cloud PubSub คือบริการส่งข้อความสำหรับเผยแพร่/สมัครรับข้อมูลจาก Google Cloud รูปแบบการสื่อสารนี้ใช้เพื่ออำนวยความสะดวกในการสื่อสารระหว่างบริการกับบริการแบบอะซิงโครนัส คล้ายกับ SNS ของ AWS การสร้างระบบด้วยการสื่อสารแบบอะซิงโครนัสสามารถช่วยปรับปรุงประสิทธิภาพ ความสามารถในการปรับขนาด และความน่าเชื่อถือของระบบของเรา ในการเริ่มต้นใช้งาน Cloud PubSub ใน Ruby เราจะใช้ google-cloud-pubsub อัญมณีในการตรวจสอบ เผยแพร่ และรับฟังเหตุการณ์:

require 'google/cloud/pubsub'

def publish_message topic_id:, message: nil
 pubsub = Google::Cloud::Pubsub.new
 topic = pubsub.topic topic_id

 topic.publish_async message do |result|
  raise "Failed to publish message" unless result.succeeded?
  puts "Message published asynchronously"
 end

 topic.async_publisher.stop.wait!
rescue StandardError => e
 puts "Received error while publishing: #{e.message}"
end

def receive_message subscription_id: nil, wait_time: 200.seconds
 pubsub = Google::Cloud::Pubsub.new

 subscription = pubsub.subscription subscription_id
 subscriber = subscription.listen do |received_message|
  puts "Received message: #{received_message.data}"
  received_message.acknowledge!
 end

 subscriber.start
 sleep wait_time
end

หมายเหตุ :การตรวจสอบสิทธิ์ที่อธิบายไว้สำหรับ Cloud Storage ยังใช้ที่นี่

เมื่อใช้ประโยชน์จาก Cloud Storage และ PubSub เราสามารถสร้างโซลูชันที่น่าสนใจได้มาก บ่อยครั้ง เราต้องการอัปโหลดออบเจ็กต์และติดตามการอัปเดต ซึ่งเป็นวงจรชีวิต สร้าง อัปเดต ลบ และดำเนินการเฉพาะตามเหตุการณ์บางอย่าง หากยังดูเหมือนนามธรรม เรามาสำรวจกรณีการใช้งานสองกรณี:

บริการรูปภาพ:การสร้างบริการรูปภาพ สมมติว่าเราต้องการสร้างสิ่งที่คล้ายกับ Cloudinary ที่ให้พื้นที่จัดเก็บรูปภาพและวิดีโอ รวมทั้งทำการแปลงข้อมูลเหล่านี้ แม้ว่า Cloud Storage จะช่วยจัดเก็บและกำหนดเวอร์ชันของข้อมูล แต่ด้วย PubSub เราสามารถรับฟังเหตุการณ์จากบัคเก็ตและทำการประมวลผลข้อมูลล่วงหน้าบางประเภทได้ แม้กระทั่งก่อนที่ลูกค้าจะขอเวอร์ชันที่ประมวลผลล่วงหน้า
แจกจ่ายไฟล์การกำหนดค่า ปัญหาทั่วไปในด้านวิศวกรรมโครงสร้างพื้นฐานกำลังเปิดตัวการกำหนดค่าไปยังเซิร์ฟเวอร์หลายเครื่องและให้การย้อนกลับที่ง่ายดาย ลองนึกภาพว่าเราต้องการมีเซิร์ฟเวอร์กลางที่รับผิดชอบการกำหนดค่าเซิร์ฟเวอร์ และเราต้องการอัปเดตการกำหนดค่าเพียงครั้งเดียว และแจกจ่ายการกำหนดค่าไปยังฟลีตของเซิร์ฟเวอร์ของเรา ด้วยการใช้ Cloud Storage และ Cloud PubSub เราสามารถสร้างตัวแทนบนเซิร์ฟเวอร์ของเราที่รับฟังผ่าน PubSub เพื่อรับการแจ้งเตือนวัตถุและดำเนินการตามเหตุการณ์เหล่านี้ นอกจากนี้ ในกรณีที่เป็นการเปลี่ยนแปลงที่ไม่ดี (การเปลี่ยนแปลงการกำหนดค่าที่ไม่ถูกต้องเป็นสาเหตุทั่วไปของการหยุดทำงาน 😩 ) เราสามารถดำเนินการย้อนกลับด้วยการกำหนดเวอร์ชันของออบเจ็กต์ได้

ในบทความนี้ เราจะสร้าง Ruby wrapper สำหรับ Blackbox Exporter โดยใช้กรณีการใช้งานที่สองที่อธิบายไว้ข้างต้น Wrapper จะเรียกใช้ผู้ส่งออกในขั้นตอนหนึ่งและเรียกใช้อีกกระบวนการหนึ่งเพื่อดูการเปลี่ยนแปลงการกำหนดค่าจากที่เก็บข้อมูลใน GCP จากนั้นจึงโหลดผู้ส่งออกใหม่ทันที คุณพร้อมไหม? มาสนุกกันเถอะ!

Blackbox Exporter คืออะไร

Blackbox Exporter เป็นเครื่องมือโอเพนซอร์สที่สร้างโดยทีม Prometheus เพื่อตรวจสอบปลายทางผ่าน HTTP, HTTPS, DNS, TCP และ ICMP ผู้ส่งออกควรปรับใช้ควบคู่ไปกับการปรับใช้ Grafana และ Prometheus การตั้งค่าที่สมบูรณ์มีลักษณะดังนี้:

สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

Wrapper Blackbox จะตรวจสอบปลายทางที่กำหนดค่าไว้ทั้งหมด และ Prometheus จะตรวจสอบผู้ส่งออกเช่นเดียวกับเป้าหมายอื่นๆ จากนั้น Grafana จะดึงข้อมูลจาก Prometheus มาสร้างกราฟ เราเรียกใช้ไบนารีของผู้ส่งออกเช่น blackbox_exporter --config.file blackbox.yml . Blackbox Exporter ยังช่วยให้เราโหลดผู้ส่งออกซ้ำด้วยการกำหนดค่าใหม่โดยไม่ต้องปิดไบนารีและเริ่มต้นใหม่ สิ่งนี้มีประโยชน์มากเมื่อทำการขูดจุดปลายด้วยช่วงเวลาที่วัดเป็นวินาที

ข้อกำหนดบริการ BlackboxWrapper

ก่อนเจาะลึกโค้ด เรามาเน้นที่ข้อกำหนดบริการกันก่อน:

The BlackboxWrapper บริการจะทำงานสองกระบวนการ
- กระบวนการแรกเรียกใช้ blackbox_exporter เลขฐานสอง.
- กระบวนการที่ 2 จะรับฟังการเปลี่ยนแปลงที่ฝากข้อมูลจาก GCP และเริ่มต้นกระบวนการแรกใหม่
บริการนี้จะถูกปรับใช้เป็นภาพนักเทียบท่า ซึ่งจะทำให้เราสามารถจัดแพ็คเกจบริการควบคู่ไปกับ blackbox_exporter เลขฐานสอง.

สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

มาเริ่มสร้างกันเลย

ขั้นแรก สร้างไดเร็กทอรีแอปแล้วป้อนไดเร็กทอรี

mkdir blackbox-wrapper && cd blackbox-wrapper

เช่นเดียวกับแอปพลิเคชัน Ruby มาตรฐาน เราจะใช้ bundler เพื่อจัดการการพึ่งพาของ wrapper ของเรา สร้าง Gemfile:

source "https://rubygems.org"

git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }

ruby '2.7.2'

gem 'google-cloud-storage'
gem 'google-cloud-pubsub'
gem 'rake'
gem 'pry'

จากนั้นเรียกใช้ bundle install .

ตอนนี้เราจะสร้างไฟล์เพื่อเก็บรหัสของเรา:app.rb .

ไฟล์นี้จะทำหน้าที่เป็นจุดเริ่มต้นของบริการของเรา เนื่องจากเราจะปรับใช้แอปของเราในคอนเทนเนอร์ ไฟล์นี้จะถูกระบุใน CMD คำสั่งใน Dockerfile . ของเรา ในภายหลัง

touch app.rb

การสร้าง Dockerfile

ในขณะที่บางรายการถูกละเว้นจากไฟล์นี้โดยตั้งใจ รหัสด้านล่างเน้นองค์ประกอบที่สำคัญที่จำเป็นสำหรับบทความนี้:

FROM ruby:2.7.2

RUN mkdir /app
WORKDIR /app
COPY . .

# Install other dependencies
...

# Download & Install blackbox exporter
RUN curl -SL \
    https://github.com/prometheus/blackbox_exporter/releases/download/v0.18.0/blackbox_exporter-0.18.0.linux-386.tar.gz | \
    tar xvz -C /tmp && \
    mv /tmp/blackbox_exporter-0.18.0.linux-386/blackbox_exporter /usr/local/bin && \
    mkdir /etc/blackbox && \
    mv /tmp/blackbox_exporter-0.18.0.linux-386/blackbox.yml /etc/blackbox/

# Specify entry point.
CMD ["bundle", "exec", "ruby", "app.rb" ]

จากข้างต้น เราควรทราบสิ่งต่อไปนี้:

เราใช้รูปภาพ Ruby - ruby:2.7.2 - เป็นอิมเมจพื้นฐานที่ติดตั้ง Ruby ไว้
เราติดตั้ง blackbox_exporter ไบนารีและย้ายไปยังไดเร็กทอรีที่สามารถเข้าถึงได้จาก PATH . ของเรา .
เราระบุจุดเข้าใช้งานของคอนเทนเนอร์เพื่อเรียกใช้ app.rb บนคอนเทนเนอร์เริ่มต้นขึ้น

การสร้างบริการ Wrapper

นี่คือบริการ Ruby ของเราที่รวมทุกอย่างเข้าด้วยกัน ใน main.rb , วางสิ่งต่อไปนี้:

require 'rubygems'
require 'bundler/setup'
require "google/cloud/pubsub"
require "google/cloud/storage"

CONFIG_BUCKET = ENV['BUCKET_NAME']
TOPIC = ENV['PUBSUB_TOPIC']
TOPIC_SUBSCRIPTION = ENV['TOPIC_SUBSCRIPTION']

class ProcessNotification

  def initialize(file, attr, blackbox_exporter)
    @file = file
    @attr = attr
    @blackbox_exporter = blackbox_exporter
  end

  def call
    return if @attr['eventType'] == 'OBJECT_DELETE'

    @blackbox_exporter.write @file
    @blackbox_exporter.reload
  end
end

class BlackBoxExporter
  CONFIG_FILE = '/etc/blackbox/blackbox.yml'

  def initialize
    @blackbox_pid = nil
  end

  def start
    return unless @blackbox_pid.nil?

    @blackbox_pid = fork do
      exec('blackbox_exporter', '--config.file', CONFIG_FILE)
    end
  end

  def write(file)
    file.download CONFIG_FILE
  end

  def reload
    # Send SIGHUP signal
    Process.kill('HUP', @blackbox_pid)
  end

  def shutdown
    Process.kill('KILL', @blackbox_pid)
  end
end

class Subscriber
  class NotificationConfigError < StandardError
  end

  SUPPORTED_FILE_TYPES = ['blackbox.yml']

  def initialize(blackbox_exporter)
    @pubsub = Google::Cloud::Pubsub.new
    @storage = Google::Cloud::Storage.new
    @subscription_name = ENV['TOPIC_SUBSCRIPTION']  # Retrieve a subscription
    @bucket = @storage.bucket CONFIG_BUCKET
    @subscription = @pubsub.subscription @subscription_name
    @blackbox_exporter = blackbox_exporter
  end

  def listen
    create_notification_config

    puts "Starting subscriber"

    @subscriber = @subscription.listen do |received_message|
      process_notification(received_message)
    end

    @subscriber.on_error do |exception|
      process_exception(exception)
    end

    @subscriber.start
  end

  def process_notification(received_message)
    data = received_message.message.data
    published_at = received_message.message.published_at
    attributes = received_message.message.attributes

    puts "Data: #{data}, published at #{published_at}, Attr: #{attributes}"
    received_message.acknowledge!

    parsed_data = JSON.parse(data)
    file_name = parsed_data['name']
    return unless SUPPORTED_FILE_TYPES.include?(file_name)

    file = @bucket.file file_name
    process_notification = ProcessNotification.new(file, attributes, @blackbox_exporter)
    process_notification.call
  end

  def process_exception(exception)
    puts "Exception: #{exception.class} #{exception.message}"
  end

  def shutdown
    @subscriber.stop!(10)
  end

  def create_notification_config
    topic = @pubsub.topic TOPIC

    notification_exists = @bucket.notifications.count == 1
    unless notification_exists
      @bucket.notifications.each do |notification|
        notification.delete
      end
    end

    @bucket.create_notification topic.name

  rescue StandardError => e
    raise NotificationConfigError, e.message
  end
end

class BlackboxWrapper
  def initialize
    @blackbox_exporter = BlackBoxExporter.new
    @subscriber = Subscriber.new(@blackbox_exporter)
  end

  def start
    @blackbox_exporter.start
    @subscriber.listen

    at_exit do
      @blackbox_exporter.shutdown
      @subscriber.shutdown
    end

    # Block, letting processing threads continue in the background
    sleep
  end
end

blackbox_wrapper = BlackboxWrapper.new
blackbox_wrapper.start

แม้ว่าด้านบนจะเป็นการเขียนโค้ดจำนวนมาก แต่ให้ลองแยกย่อยโดยเริ่มจากด้านล่าง:

BlackboxWrapper :คลาสนี้เป็นจุดเริ่มต้นของบริการของเรา - .start เมธอดทำสิ่งต่อไปนี้:
- เริ่ม blackbox_exporter ไบนารีในกระบวนการอื่นเพื่อเริ่มตรวจสอบปลายทาง
- เริ่ม subscriber ในกระบวนการอื่นเพื่อรับฟังการเปลี่ยนแปลงที่ฝากข้อมูล
- จากนั้นก็เรียก sleep ในกระบวนการหลักเพื่อให้แน่ใจว่าแอปทำงานไม่สิ้นสุด
วิธีการ BlackboxExporter ทำงาน?
- The .start เมธอดใช้ exec วิธีเคอร์เนลเพื่อเรียกใช้ blackbox_exporter ไบนารีในกระบวนการอื่น
- The .reload เมธอดส่ง SIGHUP สัญญาณให้รีโหลด blackbox_exporter ไบนารีด้วยการกำหนดค่าใหม่ ตามที่คุณอาจสังเกตเห็นจาก ProcessNotification คลาส ไฟล์คอนฟิกูเรชันใหม่จะถูกเขียนไปยังตำแหน่งไฟล์คอนฟิกูเรชันก่อนที่ผู้ส่งออกจะถูกโหลดใหม่
วิธีการ subscriber ทำงาน?
- The .listen วิธีการเริ่มต้นด้วยการสร้าง NotificationConfiguation . NotificationConfiguration เป็นกฎที่กำหนดสามสิ่ง:
  - หัวข้อในผับ/ย่อยเพื่อรับการแจ้งเตือน
  - เหตุการณ์ที่เรียกให้ส่งการแจ้งเตือน คลิกที่นี่เพื่อดูประเภทเหตุการณ์ต่างๆ ที่สามารถเรียกการแจ้งเตือนได้
  - ข้อมูลที่อยู่ในการแจ้งเตือน
- The #create_notification_config เมธอดยังช่วยให้แน่ใจว่ามีเพียง NotificationConfiguration; มิฉะนั้นจะลบทุกอย่างและสร้างใหม่ เพื่อให้แน่ใจว่ามีการส่งการแจ้งเตือนเพียงครั้งเดียว
- The .listen เมธอดยังเรียก @subscription.listen เพื่อเริ่มฟังการเปลี่ยนแปลงการแจ้งเตือนในบัคเก็ตที่เราสมัครรับข้อมูล โปรดทราบว่าการดำเนินการนี้ทำงานอย่างไม่สิ้นสุดในกระบวนการอื่นตามที่อธิบายไว้
- The #process_notification วิธีการถูกเรียกสำหรับการอัพเดทการแจ้งเตือนทุกครั้งที่ส่ง โปรดทราบว่าเรามี SUPPORTED_FILE_TYPES ซึ่งเราใช้ระบุไฟล์ในบัคเก็ตที่เราสนใจและไม่ดำเนินการใดๆ กับส่วนที่เหลือ
ProcessNotification :สิ่งนี้มีหน้าที่ในการประมวลผลการแจ้งเตือน ดาวน์โหลดการกำหนดค่าที่อัปเดต เขียนลงในไฟล์ และโหลด blackbox_exporter อีกครั้ง เลขฐานสอง.

การเรียกใช้บริการในเครื่อง

หากต้องการเรียกใช้บริการในเครื่องและทดสอบ ให้เรียกใช้สิ่งต่อไปนี้ในรูทของไดเรกทอรีแอป:

export BUCKET_NAME='{insert-bucket-name}'
export PUBSUB_TOPIC='{insert-pubsub-topic}'
export TOPIC_SUBSCRIPTION='{insert-subscription-name}'
export GOOGLE_APPLICATION_CREDENTIALS='{insert-path-to-service-key-json}'

bundle exec ruby app.rb

การใช้บริการของเรากับ Google Compute Engine

เช่นเดียวกับหลายๆ แง่มุมของคลาวด์ มีหลายวิธีที่จะได้ผลลัพธ์ที่เหมือนกัน แต่วิศวกรรมซอฟต์แวร์สมัยใหม่สนับสนุนกระบวนการ CI/CD ด้วยเหตุผลที่ดีหลายประการ ด้วยเหตุนี้ เราจะมุ่งเน้นไปที่การปรับใช้บริการของเราจาก Github Actions โดยใช้ setup-gcloud

มาตั้งค่าไฟล์การปรับใช้ของเรา (.github/workflows/deploy.yml)

name: Build and Deploy to Google Compute Engine

on:
  push:
    branches:
    - main

env:
  PROJECT_ID: ${{ secrets.GCE_PROJECT }}
  GCE_INSTANCE: ${{ secrets.GCE_INSTANCE }}
  GCE_INSTANCE_ZONE: us-central1-a
  BUCKET_NAME: demo-configurations
  PUBSUB_TOPIC: demo-configurations-bucket-notifications
  TOPIC_SUBSCRIPTION: demo-bucket-changes-subscription

jobs:
  setup-build-publish-deploy:
    name: Setup, Build, Publish, and Deploy
    runs-on: ubuntu-latest

    steps:
    - name: Checkout
      uses: actions/checkout@v2

    # Setup gcloud CLI
    - uses: google-github-actions/setup-gcloud@master
      with:
        version: '290.0.1'
        service_account_key: ${{ secrets.GCE_SA_KEY }}
        project_id: ${{ secrets.GCE_PROJECT }}

    # Configure Docker to use the gcloud command-line tool as a credential
    # helper for authentication
    - run: |-
        gcloud --quiet auth configure-docker

    # Build the Docker image
    - name: Build
      run: |-
        docker build --tag "gcr.io/$PROJECT_ID/$GCE_INSTANCE-image:$GITHUB_SHA" .

    # Push the Docker image to Google Container Registry
    - name: Publish
      run: |-
        docker push "gcr.io/$PROJECT_ID/$GCE_INSTANCE-image:$GITHUB_SHA"

    - name: Deploy
      run: |-
        gcloud compute instances update-container "$GCE_INSTANCE" \
          --zone "$GCE_INSTANCE_ZONE" \
          --container-image "gcr.io/$PROJECT_ID/$GCE_INSTANCE-image:$GITHUB_SHA" \
          --container-env "BUCKET_NAME=$BUCKET_NAME,PUBSUB_TOPIC=$PUBSUB_TOPIC,TOPIC_SUBSCRIPTION=$TOPIC_SUBSCRIPTION"

โปรดทราบว่า --container-env แฟล็กถูกตั้งค่าในเฟสการทำให้ใช้งานได้ ซึ่งช่วยให้มั่นใจว่าเราส่งผ่านตัวแปรสภาพแวดล้อมที่จำเป็นจากความลับของ Github Actions ไปยังคอนเทนเนอร์ในลักษณะที่ปลอดภัย

ความลับและตัวแปรสภาพแวดล้อม

ต่อไป เราจะตั้งค่าความลับสำหรับการกระทำของ GitHub

สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

เราตั้งค่าตัวแปรสภาพแวดล้อมสำหรับคอนเทนเนอร์ของเราด้วย --container-env ธง. เนื่องจากเรากำลังตั้งค่าจากการกระทำของ Github เราจึงสามารถใช้ข้อมูลลับสำหรับข้อมูลที่ละเอียดอ่อนหรือตัวแปร env สำหรับข้อมูลที่ไม่ละเอียดอ่อนได้

การสร้างทรัพยากร GCP

มาสร้างที่เก็บข้อมูลในคอนโซล GCP กัน

สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

เราจะสร้างหัวข้อ PubSub ในคอนโซล GCP ด้วย

สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

ตั้งค่าตัวแทนบริการของที่เก็บข้อมูลบนคลาวด์ - บทบาท IAM - pubsub.publisher ในคอนโซล แต่ละโปรเจ็กต์มีบัญชีบริการ Cloud Storage ที่เกี่ยวข้องซึ่งรับผิดชอบการดำเนินการในเบื้องหลังบางอย่าง เช่น การแจ้งเตือน PubSub คลิกที่นี่เพื่อเรียนรู้วิธีค้นหา

สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

สุดท้าย เราสร้างการสมัครรับข้อมูลในคอนโซล GCP

สร้างระบบตรวจสอบสถานะการออนไลน์ใน Ruby ด้วย GCE, Cloud Storage และ PubSub

โว้ว! 🎉 ใช้งานระบบคลาวด์ของเราเรียบร้อยแล้ว

บทสรุป

ถ้าคุณมาไกลขนาดนี้ คุณสมควรได้รับคุกกี้ 🍪 ฉันคิดว่านี่เป็นรุ่นแรกของโซลูชันที่ยอดเยี่ยมพร้อมการเพิ่มประสิทธิภาพหลายอย่างที่ต้องทำ ตัวอย่างเช่น เราสามารถบรรลุสิ่งต่อไปนี้:

ปรับใช้ blackbox_exporter เป็นฟังก์ชันแบบไม่มีเซิร์ฟเวอร์เพื่อรองรับหลายภูมิภาค ซึ่งเหมาะอย่างยิ่งสำหรับการตรวจสอบเวลาทำงาน และปรับใช้เซิร์ฟเวอร์หลักที่รับผิดชอบในการอัปเดตการกำหนดค่าบัคเก็ตใน Cloud Storage
จากจุดก่อนหน้านี้ เราอาจสรุปสิ่งนี้เป็นแอปที่รวมเข้ากับผู้ให้บริการคลาวด์ยอดนิยมเพื่อให้ได้ฟังก์ชันการทำงานเดียวกัน ดังนั้นจึงทำให้ไม่อยู่บนคลาวด์ ป.ล:ผู้ให้บริการระบบคลาวด์ยอดนิยม (GCP, AWS และ Azure) มีฟังก์ชันการทำงานเหมือนกันในทุกบริการ
ในบทความถัดไป เราจะต่อยอดจากโซลูชันนี้เพื่อให้การย้อนกลับด้วยการกำหนดเวอร์ชันออบเจ็กต์ที่เก็บข้อมูลบนคลาวด์ ซึ่งจะช่วยให้เรากู้คืนจากการอัปเดตการกำหนดค่าด้วยการอัปเดตที่ไม่ถูกต้องได้
การปรับใช้กับ Docker จะช่วยแก้ปัญหาการบรรจุภัณฑ์ให้เราได้ แต่อย่างที่คุณอาจทราบแล้ว มีหลายวิธีในการจัดแพ็คเกจบริการ ฉันเลือก Docker ในบทความนี้เพื่อความเรียบง่าย

อภิธานศัพท์

โพรมีธีอุส เป็นชุดเครื่องมือตรวจสอบและแจ้งเตือนระบบโอเพ่นซอร์ส ประกอบด้วยเซิร์ฟเวอร์ที่ดึงข้อมูลและจัดเก็บข้อมูลอนุกรมเวลา ไลบรารีไคลเอ็นต์สำหรับเครื่องมือโค้ดแอปพลิเคชัน และตัวจัดการการแจ้งเตือนเพื่อจัดการการแจ้งเตือน
กราฟาน่า เป็นระบบการแสดงภาพที่ช่วยให้คุณสามารถสืบค้น แสดงภาพ แจ้งเตือน และทำความเข้าใจเมตริกของคุณ โดยไม่คำนึงว่าจะถูกเก็บไว้ที่ใด
ผู้ส่งออกกล่องดำ เป็นเครื่องมือโอเพนซอร์สที่สร้างโดยทีม Prometheus เพื่อตรวจสอบปลายทางผ่าน HTTP, HTTPS, DNS, TCP และ ICMP