Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Ruby

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

अपटाइम मॉनिटरिंग में वेबसाइट्स, APIs, और सर्वर्स की उपलब्धता की जांच शामिल है। मॉनिटर एक निर्दिष्ट अंतराल के भीतर एक दिए गए एंडपॉइंट की जांच करता है ताकि यह निर्धारित किया जा सके कि यह उपलब्ध है या नहीं। लक्ष्य सिस्टम के SLA में निर्दिष्ट अनुबंधित उपलब्धता स्तर को प्राप्त करना है, और जब अनुबंध पूरा नहीं होता है तो अंतर निर्धारित करना है।

इस लेख में, हम Prometheus blackbox_exporter पर आधारित एक अपटाइम मॉनिटरिंग सिस्टम का निर्माण करेंगे। जबकि एक कस्टम HTTP मॉनिटरिंग सिस्टम बनाना तुच्छ हो सकता है, एक्सपोर्टर के चारों ओर एक रैपर बनाने से हमें कई अन्य प्रोब तकनीकों तक पहुंचने और हमारे सिस्टम के अन्य तत्वों को जल्दी से मॉनिटर करने में सक्षम बनाता है।

इस लेख में कई तकनीकों के उपयोग को शामिल किया गया है, और मैं अपटाइम सिस्टम के विवरण में गोता लगाने से पहले प्रत्येक घटक का वर्णन करूंगा।

Google Compute Engine (GCE) क्या है?

Compute Engine, AWS के EC2 कंप्यूट ऑफरिंग के समान, Google की क्लाउड कंप्यूटिंग सेवा है। GCE विभिन्न वर्कलोड को फिट करने के लिए पर्याप्त सुरक्षित और अनुकूलन योग्य है, छोटी मशीनों (32 vCPUs और 128 GB मेमोरी तक समर्थन) से लेकर मानक मशीनों (224 vCPUs और 896 GB मेमोरी तक समर्थन) और गहन वर्कलोड के लिए अन्य हाई-एंड मशीनों तक। यह प्रति-समय आपकी आवश्यकताओं के अनुसार स्केल करने के लिए ऑन-डिमांड कंप्यूट का उपयोग करता है।

GCE ऐप डेप्लॉयमेंट के लिए विभिन्न डेप्लॉयमेंट तंत्रों का समर्थन करता है, जिसमें कंटेनर, इंस्टेंस टेम्प्लेट, और मैनेज्ड इंस्टेंस ग्रुप शामिल हैं। इस लेख के उद्देश्य के लिए, हम अपने Ruby अपटाइम मॉनिटर को डेप्लॉयमेंट के लिए एक डॉकर कंटेनर में बंडल करेंगे।

Cloud Storage क्या है?

Google Cloud Storage, AWS की S3 सेवा के समान, एक अत्यधिक उपलब्ध ऑब्जेक्ट-स्टोरेज सेवा है। Cloud Storage कई स्टोरेज सुविधाएं प्रदान करता है जो आधुनिक ऐप्स के लिए कई उपयोग-मामलों को सक्षम बनाता है। Ruby में Cloud Storage के साथ शुरुआत करने के लिए, हम 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 द्वारा प्रदान की जाने वाली एक प्रकाशन/सदस्यता मैसेजिंग सेवा है। संचार का यह रूप AWS के SNS के समान, एसिंक्रोनस सर्विस-टू-सर्विस संचार को सुविधाजनक बनाने के लिए उपयोग किया जाता है। एसिंक्रोनस संचार के साथ सिस्टम बनाने से हमारे सिस्टम के प्रदर्शन, स्केलेबिलिटी और विश्वसनीयता को बेहतर बनाने में मदद मिल सकती है। Ruby में Cloud PubSub के साथ शुरुआत करने के लिए, हम 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 के माध्यम से ऑब्जेक्ट नोटिफिकेशन प्राप्त करने के लिए सुनते हैं और इन घटनाओं के आधार पर कार्रवाई करते हैं। इसके अलावा, यदि यह एक बुरा परिवर्तन था (गलत कॉन्फ़िगरेशन परिवर्तन डाउनटाइम का एक सामान्य कारण है 😩), तो हम ऑब्जेक्ट वर्जनिंग के साथ रोलबैक कर सकते हैं।

इस लेख में, हम ऊपर वर्णित दूसरे उपयोग-मामले का उपयोग करके Blackbox Exporter के लिए एक Ruby रैपर बनाएंगे। रैपर एक प्रक्रिया में एक्सपोर्टर चलाएगा और GCP में एक बकेट से कॉन्फ़िगरेशन परिवर्तनों को देखने के लिए दूसरी प्रक्रिया चलाएगा, और फिर एक्सपोर्टर को लाइव रीलोड करेगा। तैयार हैं? चलो मज़े करते हैं!

Blackbox Exporter क्या है?

Blackbox Exporter, Prometheus टीम द्वारा बनाया गया एक ओपन-सोर्स टूल है जो HTTP, HTTPS, DNS, TCP, और ICMP पर एंडपॉइंट्स की जांच करता है। एक्सपोर्टर को Grafana और Prometheus डेप्लॉयमेंट के साथ तैनात किया जाना चाहिए। पूरा सेटअप निम्न जैसा दिखता है:

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

Blackbox रैपर सभी कॉन्फ़िगर्ड एंडपॉइंट्स की जांच करता है, और Prometheus किसी अन्य टारगेट की तरह एक्सपोर्टर को स्क्रैप करता है। फिर, Grafana ग्राफ करने के लिए Prometheus से डेटा पुनः प्राप्त करता है। हम एक्सपोर्टर बाइनरी को blackbox_exporter --config.file blackbox.yml जैसे चलाते हैं। Blackbox Exporter हमें एक्सपोर्टर को बाइनरी को बंद किए बिना और इसे पुनः आरंभ किए बिना एक नए कॉन्फ़िगरेशन के साथ लाइव रीलोड करने की अनुमति भी देता है। यह सेकंड में मापे गए अंतराल के साथ एंडपॉइंट्स को स्क्रैप करते समय बहुत उपयोगी हो सकता है।

BlackboxWrapper सेवा स्पेक्स

कोड में गहरे गोता लगाने से पहले, आइए सेवा स्पेक्स को हाइलाइट करें:

  • BlackboxWrapper सेवा दो प्रक्रियाएं चलाएगी।
    • पहली प्रक्रिया blackbox_exporter बाइनरी चलाती है।
    • दूसरी प्रक्रिया GCP से बकेट परिवर्तनों को सुनती है और पहली प्रक्रिया को पुनः आरंभ करती है।
  • सेवा को एक डॉकर इमेज के रूप में तैनात किया जाएगा, जो हमें blackbox_exporter बाइनरी के साथ सेवा को पैकेज करने में सक्षम बनाएगा।

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

आइए निर्माण शुरू करें

सबसे पहले, एक ऐप डायरेक्टरी बनाएं और फिर डायरेक्टरी में प्रवेश करें।

mkdir blackbox-wrapper && cd blackbox-wrapper

हमारे मानक Ruby एप्लिकेशन की तरह, हम अपने रैपर की निर्भरताओं को प्रबंधित करने के लिए bundler का उपयोग करेंगे। एक 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।

यह फाइल हमारी सेवा के लिए प्रवेश बिंदु के रूप में कार्य करेगी। चूंकि हम अपने ऐप को एक कंटेनर में डेप्लॉय करेंगे, इस फाइल को बाद में हमारे Dockerfile में CMD कमांड में निर्दिष्ट किया जाएगा।

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 चलाने के लिए निर्दिष्ट किया।

रैपर सेवा का निर्माण

यह हमारी 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 कैसे काम करता है?
    • .start विधि exec कर्नेल विधि का उपयोग करके blackbox_exporter बाइनरी को दूसरी प्रक्रिया में चलाती है।
    • .reload विधि blackbox_exporter बाइनरी को नए कॉन्फ़िगरेशन के साथ लाइव रीलोड करने के लिए SIGHUP सिग्नल भेजती है। जैसा कि आप ProcessNotification क्लास से देख सकते हैं, एक्सपोर्टर को रीलोड करने से पहले एक नई कॉन्फ़िगरेशन फाइल कॉन्फ़िगरेशन फाइल स्थान पर लिखी जाती है।
  • Subscriber कैसे काम करता है?
    • .listen विधि NotificationConfiguration बनाने से शुरू होती है। एक NotificationConfiguration एक नियम है जो तीन चीजों को निर्दिष्ट करता है:
      • Pub/Sub में एक टॉपिक जहां नोटिफिकेशन प्राप्त होंगे।
      • वह घटना जो नोटिफिकेशन भेजे जाने को ट्रिगर करती है। विभिन्न इवेंट प्रकार देखने के लिए यहां क्लिक करें जो नोटिफिकेशन ट्रिगर कर सकते हैं।
      • नोटिफिकेशन के भीतर निहित जानकारी।
    • #create_notification_config विधि यह भी सुनिश्चित करती है कि केवल एक NotificationConfiguration है; अन्यथा, यह सब कुछ हटा देगा और एक बनाएगा। यह सुनिश्चित करता है कि नोटिफिकेशन केवल एक बार भेजे जाते हैं।
    • .listen विधि @subscription.listen को कॉल करके उस बकेट के लिए नोटिफिकेशन परिवर्तनों को सुनना शुरू करती है जिसकी हमने सदस्यता ली है। ध्यान दें कि यह दूसरी प्रक्रिया में अनिश्चित काल तक चलता है, जैसा कि समझाया गया है।
    • #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 प्रक्रियाओं को प्रोत्साहित करती है। इस प्रकार, हम setup-gcloud का उपयोग करके Github Actions से अपनी सेवा को तैनात करने पर ध्यान केंद्रित करेंगे

आइए अपनी डेप्लॉयमेंट फाइल (.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 Actions के लिए सीक्रेट्स सेटअप करेंगे।

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

हम --container-env फ्लैग के साथ अपने कंटेनर के लिए पर्यावरण चर सेट करते हैं। चूंकि हम इसे Github Actions से सेट कर रहे हैं, हम संवेदनशील डेटा के लिए सीक्रेट्स या गैर-संवेदनशील डेटा के लिए पर्यावरण चर का उपयोग कर सकते हैं।

GCP संसाधन बनाना

आइए GCP कंसोल में एक बकेट बनाएं।

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

हम GCP कंसोल में एक PubSub टॉपिक भी बनाएंगे।

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

क्लाउड स्टोरेज बकेट के सर्विस एजेंट को सेट करें - IAM भूमिका - कंसोल में pubsub.publisher। प्रत्येक प्रोजेक्ट में एक संबद्ध क्लाउड स्टोरेज सर्विस अकाउंट होता है जो कुछ पृष्ठभूमि क्रियाओं के लिए जिम्मेदार होता है, जैसे PubSub नोटिफिकेशन। इसे खोजने का तरीका जानने के लिए यहां क्लिक करें।

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

अंत में, हम GCP कंसोल में एक सब्सक्रिप्शन बनाते हैं।

GCE, Cloud Storage, और Pub/Sub का उपयोग करके Ruby में एक विश्वसनीय अपटाइम मॉनिटरिंग सिस्टम बनाएं

वोइला! 🎉 हमारा क्लाउड फंक्शन सफलतापूर्वक तैनात किया गया है।

निष्कर्ष

यदि आप यहां तक पहुंचे हैं, तो आप एक कुकी के हकदार हैं 🍪। मुझे लगता है कि यह कई अनुकूलनों के साथ एक संभावित महान समाधान का पहला संस्करण है। उदाहरण के लिए, हम निम्नलिखित प्राप्त कर सकते हैं:

  • Blackbox_exporter को सर्वरलेस फंक्शन के रूप में तैनात करें ताकि कई क्षेत्रों का समर्थन किया जा सके, जो अपटाइम मॉनिटरिंग के लिए आदर्श है, और एक मास्टर सर्वर तैनात करें जो क्लाउड स्टोरेज में बकेट कॉन्फ़िगरेशन को अपडेट करने के लिए जिम्मेदार हो।
  • संभावित रूप से, पिछले बिंदु से, हम इसे एक ऐप में अमूर्त कर सकते हैं जो लोकप्रिय क्लाउड प्रोवाइडर्स के साथ एकीकृत होता है ताकि समान कार्यक्षमता प्राप्त की जा सके, इसलिए इसे क्लाउड-अज्ञेयवादी बनाया जा सके। P.S: लोकप्रिय क्लाउड प्रोवाइडर्स (GCP, AWS, & Azure) सेवाओं में समान कार्यक्षमता प्रदान करते हैं।

  • अगले लेख में, हम क्लाउड-स्टोरेज ऑब्जेक्ट वर्जनिंग के साथ रोलबैक प्रदान करने के लिए इस समाधान पर निर्माण करेंगे, जो हमें गलत अपडेट के साथ कॉन्फ़िगरेशन अपडेट करने से पुनर्प्राप्त करने में सक्षम करेगा।

  • Docker के साथ डेप्लॉय करना केवल हमारे लिए पैकेजिंग समस्या को हल करता है, लेकिन जैसा कि आप पहले से ही जानते होंगे, सेवाओं को पैकेज करने के विभिन्न तरीके हैं। मैंने इस लेख में सरलता के लिए Docker को चुना।

शब्दावली

  • Prometheus एक ओपन-सोर्स सिस्टम मॉनिटरिंग और अलर्टिंग टूलकिट है। इसमें एक सर्वर शामिल है जो टाइम-सीरीज डेटा को स्क्रैप और स्टोर करता है, एप्लिकेशन कोड को इंस्ट्रूमेंट करने के लिए क्लाइंट लाइब्रेरीज, और अलर्ट को संभालने के लिए एक अलर्ट मैनेजर।
  • Grafana एक विज़ुअलाइज़ेशन सिस्टम है जो आपको अपने मेट्रिक्स को क्वेरी, विज़ुअलाइज़, अलर्ट और समझने की अनुमति देता है, चाहे वे कहीं भी संग्रहीत हों।
  • Blackbox Exporter Prometheus टीम द्वारा बनाया गया एक ओपन-सोर्स टूल है जो HTTP, HTTPS, DNS, TCP, और ICMP पर एंडपॉइंट्स की जांच करता है।
  1. SwiftUI के साथ एक मजबूत डिजाइन सिस्टम बनाना: एक पूर्ण गाइड SwiftUI के साथ एक मजबूत डिजाइन सिस्टम बनाना: एक पूर्ण गाइड

    एक उत्पाद का समर्थन करने के लिए एक डिजाइन सिस्टम बनाना आसान नहीं है - इसे स्केलेबिलिटी के लिए मजबूत और लचीला दोनों होना चाहिए। हालांकि चुनौतीपूर्ण, बहुत सारे बेहतरीन संसाधनों ने उपयोगी सिद्धांतों और दृष्टिकोणों को साझा किया है जो टीमों को विजुअल और प्रोग्रामेटिक दोनों रूप से एक अच्छा सिस्टम बनाने मे

  1. क्लाउड ट्यूनअप प्रो से इंटरनेट कुकीज और सिस्टम रजिस्ट्री स्कैन करें ताकि PC का प्रदर्शन चरम पर हो क्लाउड ट्यूनअप प्रो से इंटरनेट कुकीज और सिस्टम रजिस्ट्री स्कैन करें ताकि PC का प्रदर्शन चरम पर हो

    ऑप्टिमाइज़ेशन का मतलब कंप्यूटर को साफ करना और बनाए रखना है ताकि इष्टतम प्रदर्शन और गति प्राप्त हो सके। नियमित ऑप्टिमाइज़ेशन के साथ, आपका PC हर समय निर्दोष रूप से कार्य करता है। अपने कंप्यूटर को ऑप्टिमाइज़ करना मैन्युअली या थर्ड-पार्टी टूल की मदद से किया जा सकता है। पूर्व विधि में बहुत समय लग सकता है

  1. क्लाउड स्टोरेज: सुरक्षित डेटा स्टोरेज और ट्रांसफर के लिए अग्रणी नवाचार क्लाउड स्टोरेज: सुरक्षित डेटा स्टोरेज और ट्रांसफर के लिए अग्रणी नवाचार

    मनुष्य हमेशा अपने मस्तिष्क कोशिकाओं के अलावा एक बाहरी माध्यम पर भरोसा करता रहा है ताकि भविष्य की पीढ़ियों के लिए या अपनी यादों को संरक्षित करने के लिए जानकारी स्टोर और पास कर सके। प्रारंभिक निएंडरथल से जिन्होंने गीली मिट्टी और कीचड़ और गुफा की दीवारों पर नक्काशी का उपयोग किया, अधिक प्रगतिशील मिस्रवा