रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

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

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

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

Google कंप्यूट इंजन (GCE) क्या है?

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

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

क्लाउड स्टोरेज क्या है?

Google क्लाउड स्टोरेज AWS की S3 सेवा के समान एक अत्यधिक उपलब्ध ऑब्जेक्ट-स्टोरेज सेवा है। क्लाउड स्टोरेज कई स्टोरेज सुविधाएं प्रदान करता है जो आधुनिक ऐप्स के लिए कई उपयोग-मामलों को सक्षम करता है। रूबी में क्लाउड स्टोरेज के साथ आरंभ करने के लिए, हम google-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 में चल रहा है, हालांकि, यह पहले से ही परिवेश में सेट है।

क्लाउड पबसुब क्या है?

क्लाउड पबसुब Google क्लाउड द्वारा प्रदान की जाने वाली एक प्रकाशित/सदस्यता संदेश सेवा है। संचार के इस रूप का उपयोग एडब्ल्यूएस के एसएनएस के समान अतुल्यकालिक सेवा-से-सेवा संचार की सुविधा के लिए किया जाता है। एसिंक्रोनस संचार के साथ बिल्डिंग सिस्टम हमारे सिस्टम के प्रदर्शन, मापनीयता और विश्वसनीयता को बेहतर बनाने में मदद कर सकते हैं। रूबी में 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

नोट :क्लाउड स्टोरेज के लिए वर्णित प्रमाणीकरण यहां भी लागू होता है।

क्लाउड स्टोरेज और पबसुब का लाभ उठाते हुए, हम बहुत ही रोचक समाधान बना सकते हैं। अक्सर, हम किसी ऑब्जेक्ट को अपलोड करना चाहते हैं और अपडेट ट्रैक करना चाहते हैं - यह जीवन-चक्र है - कुछ घटनाओं के आधार पर विशिष्ट क्रियाएं बनाएं, अपडेट करें, हटाएं और करें। यदि यह अभी भी सारगर्भित लगता है, तो आइए दो उपयोग-मामलों को देखें:

छवि सेवा:एक छवि सेवा का निर्माण। मान लीजिए कि हम क्लाउडिनरी के समान कुछ बनाना चाहते हैं जो छवि और वीडियो भंडारण प्रदान करता है, साथ ही इन डेटा पर परिवर्तन भी करता है। जबकि क्लाउड स्टोरेज डेटा को स्टोर और वर्जन करने में मदद कर सकता है, पबसब के साथ, हम एक बकेट से ईवेंट सुन सकते हैं और डेटा पर कुछ प्रकार के प्री-प्रोसेसिंग कर सकते हैं, इससे पहले कि ग्राहक प्री-प्रोसेस्ड वर्जन का अनुरोध करता हो।
कॉन्फ़िगरेशन फ़ाइलें वितरित करें। इन्फ्रास्ट्रक्चर इंजीनियरिंग में एक आम समस्या कई सर्वरों के लिए कॉन्फ़िगरेशन को रोल आउट करना और आसान रोलबैक प्रदान करना है। कल्पना कीजिए कि हम सर्वर कॉन्फ़िगरेशन के लिए जिम्मेदार एक केंद्रीय सर्वर चाहते हैं, और हम कॉन्फ़िगरेशन को एक बार अपडेट करना चाहते हैं और कॉन्फ़िगरेशन को हमारे सर्वर के बेड़े में वितरित करना चाहते हैं। क्लाउड स्टोरेज और क्लाउड पबसुब का उपयोग करके, हम अपने सर्वर पर एजेंट बना सकते हैं जो ऑब्जेक्ट नोटिफिकेशन प्राप्त करने और इन घटनाओं के आधार पर कार्रवाई करने के लिए पबसुब के माध्यम से सुनते हैं। इसके अलावा, इस घटना में कि यह एक खराब परिवर्तन था (गलत कॉन्फ़िगरेशन परिवर्तन डाउनटाइम के लिए एक सामान्य कारण है ), हम ऑब्जेक्ट वर्जनिंग के साथ रोलबैक कर सकते हैं।

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

ब्लैकबॉक्स एक्सपोर्टर क्या है?

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

रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

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

ब्लैकबॉक्सवापर सेवा विनिर्देश

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

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

रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

आइए बिल्डिंग शुरू करें

सबसे पहले, एक ऐप निर्देशिका बनाएं और फिर निर्देशिका दर्ज करें।

mkdir blackbox-wrapper && cd blackbox-wrapper

हमारे मानक रूबी एप्लिकेशन की तरह, हम bundler . का उपयोग करेंगे हमारे रैपर की निर्भरता को प्रबंधित करने के लिए। एक जेमफाइल बनाएं:

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 run चलाएं ।

अब हम अपना कोड रखने के लिए एक फाइल बनाएंगे:app.rb ।

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

touch app.rb

डॉकरफ़ाइल बनाना

जबकि कुछ वस्तुओं को इस फ़ाइल से उद्देश्य से हटा दिया गया है। नीचे दिया गया कोड इस लेख के लिए आवश्यक महत्वपूर्ण घटकों पर प्रकाश डालता है:

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:2.7.2 - रूबी स्थापित के साथ एक मूल छवि के रूप में।
हमने blackbox_exporter स्थापित किया है बाइनरी और इसे हमारे PATH . से सुलभ निर्देशिका में ले जाया गया ।
हमने app.rb run चलाने के लिए कंटेनर का प्रवेश बिंदु निर्दिष्ट किया है कंटेनर स्टार्ट अप पर।

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

यह हमारी रूबी सेवा है जो सब कुछ एक साथ जोड़ती है। 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 calls को कॉल करता है मुख्य प्रक्रिया में यह सुनिश्चित करने के लिए कि ऐप असीमित रूप से चलता है।
BlackboxExporter कैसे करता है काम?
- .start विधि exec . का उपयोग करती है blackbox_exporter को चलाने के लिए कर्नेल विधि किसी अन्य प्रक्रिया में बाइनरी।
- .reload विधि SIGHUP भेजती है blackbox_exporter . को लाइव रीलोड करने का संकेत नए विन्यास के साथ बाइनरी। जैसा कि आपने ProcessNotification . से नोट किया होगा वर्ग, निर्यातक के पुनः लोड होने से पहले कॉन्फ़िगरेशन फ़ाइल स्थान पर एक नई कॉन्फ़िगरेशन फ़ाइल लिखी जाती है।
subscriber कैसे करता है काम?
- .listen विधि NotificationConfiguation बनाने के साथ शुरू होती है . एक NotificationConfiguration एक नियम है जो तीन चीजों को निर्दिष्ट करता है:
  - पब/उप में एक विषय सूचनाएं प्राप्त करने के लिए।
  - वह घटना जो सूचनाओं को भेजने के लिए ट्रिगर करती है। अधिसूचनाओं को ट्रिगर करने वाले विभिन्न प्रकार के ईवेंट देखने के लिए यहां क्लिक करें।
  - सूचनाओं में निहित जानकारी।
- द #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 कंप्यूट इंजन में परिनियोजित करना

क्लाउड के कई पहलुओं की तरह, समान परिणाम प्राप्त करने के कई तरीके हैं, लेकिन आधुनिक सॉफ्टवेयर इंजीनियरिंग कई अच्छे कारणों से CI/CD प्रक्रियाओं को प्रोत्साहित करती है। जैसे, हम सेटअप-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 के रहस्यों से आवश्यक पर्यावरण चर को सुरक्षित तरीके से कंटेनर में पास करते हैं।

रहस्य और पर्यावरण चर

इसके बाद, हम जीथब क्रियाओं के लिए रहस्य स्थापित करेंगे।

रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

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

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

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

रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

हम GCP कंसोल में एक PubSub विषय भी बनाएंगे।

रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

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

रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

अंत में, हम GCP कंसोल में एक सदस्यता बनाते हैं।

रूबी में GCE, क्लाउड स्टोरेज और PubSub के साथ एक अपटाइम मॉनिटरिंग सिस्टम बनाएं

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

निष्कर्ष

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

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

शब्दावली

प्रोमेथियस टूलकिट की निगरानी और चेतावनी देने वाला एक ओपन-सोर्स सिस्टम है। इसमें एक सर्वर शामिल है जो समय-श्रृंखला डेटा को स्क्रैप और स्टोर करता है, एप्लिकेशन कोड के लिए क्लाइंट लाइब्रेरी, और अलर्ट को संभालने के लिए एक अलर्ट मैनेजर।
ग्राफाना एक विज़ुअलाइज़ेशन सिस्टम है जो आपको अपने मेट्रिक को क्वेरी करने, विज़ुअलाइज़ करने, अलर्ट करने और समझने की अनुमति देता है, भले ही वे कहीं भी संग्रहीत हों।
ब्लैकबॉक्स निर्यातक HTTP, HTTPS, DNS, TCP और ICMP पर एंडपॉइंट की जांच के लिए प्रोमेथियस टीम द्वारा निर्मित एक ओपन-सोर्स टूल है।