ऑटो शटडाउन और स्टार्ट अमेज़ॅन EC2 इंस्टेंस

Question 1

क्या मैं अमेज़ॅन एपीआई का उपयोग करके अपने अमेज़ॅन उदाहरण को स्वचालित रूप से शुरू और समाप्त कर सकता हूं? क्या आप यह बता सकते हैं कि यह कैसे किया जा सकता है? मुझे आदर्श रूप से उदाहरण शुरू करने और हर दिन निर्दिष्ट समय अंतराल पर उदाहरण को रोकने की आवश्यकता है।

Question 2

बस अगर कोई इस पुराने सवाल पर ठोकर खाता है, तो आजकल आप ऑटो स्केलिंग समूह में एक शेड्यूल जोड़कर एक ही चीज़ प्राप्त कर सकते हैं: निश्चित समय पर ऑटो स्केलिंग समूह में इंस्टेंस की मात्रा को बढ़ाकर 1 कर दें और बाद में इसे घटाकर 0 कर दें। ।

और जब से इस उत्तर को बहुत सारे विचार मिल रहे हैं, मैंने इस बारे में एक बहुत ही उपयोगी मार्गदर्शिका से जुड़ने के बारे में सोचा: ऑटो स्केलिंग के साथ आवर्ती अनुसूची पर चल रहे EC2 उदाहरण

Question 3

आप सीधे Amazon EC2 API टूल का उपयोग करके देख सकते हैं। वास्तव में केवल दो आज्ञाएँ हैं जिनकी आपको आवश्यकता है: ec2-start-instances और ec2-stop-instances। सुनिश्चित करें कि पर्यावरण चर जैसे कि EC2_HOME, AWS_CREDENTIAL_FILE, EC2_CERT, EC2_PRIVATE_KEY, आदि को ठीक से कॉन्फ़िगर किया गया है और सभी AWS क्रेडेंशियल्स, प्रमाणपत्र और निजी कुंजी फ़ाइलें उचित स्थान पर हैं - आप AWS EC2 API टूल प्रलेखन में अधिक जानकारी पा सकते हैं।

आप पहले हाथ से कमांड का परीक्षण कर सकते हैं और फिर, जब सब कुछ ठीक हो जाता है, तो विंडोज पर यूनिक्स क्रॉस्टैब या शेड्यूल किए गए कार्य कॉन्फ़िगर करें। आप लिनक्स / etc / crontab फ़ाइल के लिए नीचे दिए गए उदाहरण पा सकते हैं (यह मत भूलिए कि उपर्युक्त सभी पर्यावरण चर 'आपके-खाता' उपयोगकर्ता के लिए मौजूद होने की आवश्यकता है।

/etc/crontab
0 8     * * *   your-account ec2-start-instances <your_instance_id>
0 16    * * *   your-account ec2-stop-instances <your_instance_id>
# Your instance will be started at 8am and shutdown at 4pm.

मैं BitNami क्लाउड प्रोजेक्ट के लिए एक डेवलपर हूं, जहां हम AWS टूल (जिनमें मैंने उल्लेख किया है सहित) को मुफ्त में इंस्टॉलर का उपयोग करना आसान है, जिसे आप आज़माना चाहते हैं: BitNami CloudTools pack stack

Question 4

मैं आपको EC2 गेटिंग स्टार्टेड गाइड पर एक नज़र डालने की सलाह देता हूं , जो आपको दिखाता है कि EC2 कमांड लाइन टूल का उपयोग करने के लिए आपको क्या करना चाहिए। आप इसे आसानी से एक क्रोन जॉब (लिनक्स / यूनिक्स पर) या विंडोज पर अनुसूचित नौकरी में शुरू करने और एक निश्चित समय पर कमांड को रोकने के लिए लिख सकते हैं।

यदि आप अपने स्वयं के कोड से ऐसा करना चाहते हैं, तो आप SOAP या REST API का उपयोग कर सकते हैं; देखने के विकासकर्ता गाइड जानकारी के लिए।

Question 5

मैंने ऐसा करने के लिए बोटो लाइब्रेरी का उपयोग करते हुए पायथन में कोड लिखा। आप इसे अपने उपयोग के लिए समायोजित कर सकते हैं। इसे क्रोन जॉब के हिस्से के रूप में चलाना सुनिश्चित करें, और फिर आप क्रोन जॉब्स चलाने के दौरान जितनी जरूरत हो उतने स्टार्ट-अप या शट-डाउन कर सकेंगे।

#!/usr/bin/python
#
# Auto-start and stop EC2 instances
#
import boto, datetime, sys
from time import gmtime, strftime, sleep

# AWS credentials
aws_key = "AKIAxxx"
aws_secret = "abcd"

# The instances that we want to auto-start/stop
instances = [
    # You can have tuples in this format:
    # [instance-id, name/description, startHour, stopHour, ipAddress]
    ["i-12345678", "Description", "00", "12", "1.2.3.4"]
]

# --------------------------------------------

# If its the weekend, then quit
# If you don't care about the weekend, remove these three 
# lines of code below.
weekday = datetime.datetime.today().weekday()
if (weekday == 5) or (weekday == 6):
    sys.exit()

# Connect to EC2
conn = boto.connect_ec2(aws_key, aws_secret)

# Get current hour
hh = strftime("%H", gmtime())

# For each instance
for (instance, description, start, stop, ip) in instances:
    # If this is the hour of starting it...
    if (hh == start):
        # Start the instance
        conn.start_instances(instance_ids=[instance])
        # Sleep for a few seconds to ensure starting
        sleep(10)
        # Associate the Elastic IP with instance
        if ip:
            conn.associate_address(instance, ip)
    # If this is the hour of stopping it...
    if (hh == stop):
        # Stop the instance
        conn.stop_instances(instance_ids=[instance])

Question 6

यदि यह महत्वपूर्ण मिशन नहीं है - एक साधारण बात यह है कि हर दिन 3 बजे 'SHUTDOWN' (विंडोज़) चलाने के लिए बैच फ़ाइल को शेड्यूल करना है। फिर कम से कम आप गलती से अनिश्चित काल तक चलने वाले अवांछित उदाहरण को छोड़ने का जोखिम नहीं उठाते हैं।

जाहिर है कि यह केवल आधी कहानी है!

Question 7

जिस कंपनी के लिए मैं काम करता हूं, वह नियमित रूप से ग्राहकों से इस बारे में पूछती है, इसलिए हमने यहां फ्रीवेयर EC2 शेड्यूलिंग ऐप उपलब्ध कराया है:

http://blog.simple-help.com/2012/03/free-ec2-scheduler/

यह विंडोज और मैक पर काम करता है, आपको कई दैनिक / साप्ताहिक / मासिक शेड्यूल बनाने देता है और आपको बड़ी संख्या में उदाहरणों को आसानी से शामिल करने के लिए या भविष्य में आपके द्वारा जोड़े जाने वाले फिल्टर का उपयोग करने देता है।

Question 8

AWS डेटा पाइपलाइन ठीक काम कर रही है। https://aws.amazon.com/premiumsupport/knowledge-center/stop-start-ec2-instances/

यदि आप शुरू होने वाले दिनों को छोड़ना चाहते हैं (उदाहरण के लिए सप्ताहांत) तो ShellCommandPrecondition ऑब्जेक्ट जोड़ें।

AWS कंसोल / डेटा पाइपलाइन में, एक नई पाइपलाइन बनाएँ। परिभाषा को संपादित करना / आयात करना आसान है (JSON)

    {
"objects": [
{
  "failureAndRerunMode": "CASCADE",
  "schedule": {
    "ref": "DefaultSchedule"
  },
  "resourceRole": "DataPipelineDefaultResourceRole",
  "role": "DataPipelineDefaultRole",
  "pipelineLogUri": "s3://MY_BUCKET/log/",
  "scheduleType": "cron",
  "name": "Default",
  "id": "Default"
},
{
  "name": "CliActivity",
  "id": "CliActivity",
  "runsOn": {
    "ref": "Ec2Instance"
  },
  "precondition": {
    "ref": "PreconditionDow"
  },
  "type": "ShellCommandActivity",
  "command": "(sudo yum -y update aws-cli) && (#{myAWSCLICmd})"
},
{
  "period": "1 days",
  "startDateTime": "2015-10-27T13:00:00",
  "name": "Every 1 day",
  "id": "DefaultSchedule",
  "type": "Schedule"
},
{
  "scriptUri": "s3://MY_BUCKET/script/dow.sh",
  "name": "DayOfWeekPrecondition",
  "id": "PreconditionDow",
  "type": "ShellCommandPrecondition"
},
{
  "instanceType": "t1.micro",
  "name": "Ec2Instance",
  "id": "Ec2Instance",
  "type": "Ec2Resource",
  "terminateAfter": "50 Minutes"
}
],
"parameters": [
{
  "watermark": "aws [options] <command> <subcommand> [parameters]",
  "description": "AWS CLI command",
  "id": "myAWSCLICmd",
  "type": "String"
}
 ],
"values": {
"myAWSCLICmd": "aws ec2 start-instances --instance-ids i-12345678 --region eu-west-1"
}
}

अपने S3 बाल्टी में पूर्व शर्त के रूप में dowloaded और निष्पादित होने के लिए बैश स्क्रिप्ट रखो

#!/bin/sh
if [ "$(date +%u)" -lt 6 ]
then exit 0
else exit 1
fi

सप्ताहांत के दिनों में पाइपलाइन को सक्रिय और चलाने पर, AWS कंसोल पाइपलाइन हेल्थ स्टेटस एक भ्रामक "ERROR" पढ़ता है। बैश स्क्रिप्ट एक त्रुटि (1 बाहर निकलें) और EC2 शुरू नहीं होती है। 1 से 5 दिन पर, स्थिति "स्वास्थ्य" है।

EC2 को स्वचालित रूप से कार्यालय समय पर बंद करने के लिए, AWS CLI कमांड दैनिक wihtout पूर्व शर्त का उपयोग करें।

Question 9

आप ऐसा करने के लिए यलास्टिक को देख सकते थे । वैकल्पिक रूप से ऐसा लगता है कि एक मशीन चल रही है जो क्रोन जॉब या शेड्यूल किए गए कार्य का उपयोग करके अन्य इंस्टेंसेस को बंद कर देती है।

जाहिर है अगर आप केवल एक उदाहरण चाहते हैं तो यह एक महंगा समाधान है, क्योंकि एक मशीन को हमेशा चालू रखना पड़ता है, और क्रॉन जॉब चलाने के लिए एक मशीन के लिए प्रति माह ~ $ 80 का भुगतान करना प्रभावी नहीं होता है।

Question 10

AutoScaling समाप्त उदाहरणों तक सीमित है। यदि आप किसी इंस्टेंस को रोकना चाहते हैं और सर्वर स्थिति को बनाए रखना चाहते हैं तो एक बाहरी स्क्रिप्ट सबसे अच्छा तरीका है।

आप एक अन्य उदाहरण पर नौकरी चलाकर ऐसा कर सकते हैं जो 24/7 चल रहा है या आप एक 3 पार्टी सेवा जैसे कि Ylastic (ऊपर उल्लेखित) या रॉकेट पीक का उपयोग कर सकते हैं ।

उदाहरण के लिए C # में सर्वर को रोकने का कोड काफी सीधा है:

public void stopInstance(string instance_id, string AWSRegion)
        {
            RegionEndpoint myAWSRegion = RegionEndpoint.GetBySystemName(AWSRegion);
            AmazonEC2 ec2 = AWSClientFactory.CreateAmazonEC2Client(AWSAccessKey, AWSSecretKey, myAWSRegion);
            ec2.StopInstances(new StopInstancesRequest().WithInstanceId(instance_id));
        }

Question 11

IMHO एक ऑटो स्केलिंग समूह में एक शेड्यूल जोड़ना सबसे अच्छा "क्लाउड जैसा" दृष्टिकोण है जैसा कि पहले उल्लेख किया गया है।

लेकिन अगर आप अपने उदाहरणों को समाप्त नहीं कर सकते हैं और नए लोगों का उपयोग कर सकते हैं, उदाहरण के लिए यदि आपके पास इलास्टिक आईपी आदि से जुड़े हैं।

आप एक तिथि समय सीमा के आधार पर अपने उदाहरण शुरू करने और रोकने के लिए एक रूबी स्क्रिप्ट बना सकते हैं।

#!/usr/bin/env ruby

# based on https://github.com/phstc/amazon_start_stop

require 'fog'
require 'tzinfo'

START_HOUR = 6 # Start 6AM
STOP_HOUR  = 0 # Stop  0AM (midnight)

conn = Fog::Compute::AWS.new(aws_access_key_id:     ENV['AWS_ACCESS_KEY_ID'],
                             aws_secret_access_key: ENV['AWS_SECRET_ACCESS_KEY'])

server = conn.servers.get('instance-id')

tz = TZInfo::Timezone.get('America/Sao_Paulo')

now = tz.now

stopped_range = (now.hour >= STOP_HOUR && now.hour < START_HOUR)
running_range = !stopped_range

if stopped_range && server.state != 'stopped'
  server.stop
end

if running_range && server.state != 'running'
  server.start

  # if you need an Elastic IP
  # (everytime you stop an instance Amazon dissociates Elastic IPs)
  #
  # server.wait_for { state == 'running' }
  # conn.associate_address server.id, 127.0.0.0
end

Heroku Scheduler का उपयोग करके मुफ्त में शेड्यूलर बनाने के लिए amazon_start_stop पर एक नज़र डालें ।

Question 12

भले ही ऑटो स्केलिंग का उपयोग करके इसे प्राप्त करने के तरीके हैं, यह सभी अवसरों के लिए उपयुक्त नहीं है क्योंकि यह उदाहरणों को समाप्त करता है। क्रोन नौकरियां कभी भी एक उदाहरण के लिए काम नहीं करेंगी (हालांकि यह पूरी तरह से एकल उदाहरण को रोकने और कई उदाहरणों को चलाने के दौरान अन्य उदाहरणों को शेड्यूल करने जैसी स्थितियों के लिए उपयोग किया जा सकता है)। आप एक ही प्राप्त करने के लिए StartInstancesRequest , और StopInstancesRequest जैसी API कॉल का उपयोग कर सकते हैं लेकिन फिर से आपको तीसरे संसाधन पर निर्भर रहना होगा। AWS उदाहरणों को कई विशेषताओं के साथ शेड्यूल करने के लिए कई एप्लिकेशन हैं लेकिन एक सरल समाधान के लिए मैं एक स्वतंत्र ऐप की सिफारिश करूंगा जैसे कि Snapleaf .io

Question 13

हां, आप ऐसा कर सकते हैं कि AWS लैम्ब्डा का उपयोग कर सकते हैं। आप क्लाउडवाच में ट्रिगर का चयन कर सकते हैं जो UTC पर क्रोन के भावों पर चलता है।

यहां संबंधित लिंक https://aws.amazon.com/premiumsupport/knowledge-center/start-stop-lambda-cloudwatch/

एक अन्य विकल्प उपयोग करने के लिए है awscli, जो उपलब्ध है pip, apt-get, yumया brew, और फिर चल aws configureआपके क्रेडेंशियल्स IAM से निर्यात के साथ और निम्नलिखित बैश स्क्रिप्ट निष्पादित करने, एक EC2 कि साथ टैग किया गया रोकने के लिए Name: Appnameऔर Value: Appname Prod। आप awscliअपने उदाहरणों को टैग करने के लिए उपयोग कर सकते हैं या इसे एडब्ल्यूएस कंसोल से मैन्युअल रूप से टैग कर सकते हैं । aws ec2 stop-instancesइंस्टेंस को रोक देगा और jqjson क्वेरी को फ़िल्टर करने और टैग्स का उपयोग करके सही इंस्टेंस आईडी लाने के लिए उपयोग किया जाता है aws ec2 describe-instances।

यह सत्यापित करने के लिए कि aws configureसफल रहा है और json आउटपुट रन देता है और आउटपुट में aws ec2 describe-instancesआपका रनिंग इंस्टेंस आईडी होना चाहिए। यहाँ एक नमूना आउटपुट है

{
    "Reservations": [
        {
            "Instances": [
                {
                    "Monitoring": {
                        "State": "disabled"
                    },
                    "PublicDnsName": "ec2-xxx.ap-south-1.compute.amazonaws.com",
                    "State": {
                        "Code": xx,
                        "Name": "running"
                    },
                    "EbsOptimized": false,
                    "LaunchTime": "20xx-xx-xxTxx:16:xx.000Z",
                    "PublicIpAddress": "xx.127.24.xxx",
                    "PrivateIpAddress": "xxx.31.3.xxx",
                    "ProductCodes": [],
                    "VpcId": "vpc-aaxxxxx",
                    "StateTransitionReason": "",
                    "InstanceId": "i-xxxxxxxx",
                    "ImageId": "ami-xxxxxxx",
                    "PrivateDnsName": "ip-xxxx.ap-south-1.compute.internal",
                    "KeyName": "node",
                    "SecurityGroups": [
                        {
                            "GroupName": "xxxxxx",
                            "GroupId": "sg-xxxx"
                        }
                    ],
                    "ClientToken": "",
                    "SubnetId": "subnet-xxxx",
                    "InstanceType": "t2.xxxxx",
                    "NetworkInterfaces": [
                        {
                            "Status": "in-use",
                            "MacAddress": "0x:xx:xx:xx:xx:xx",
                            "SourceDestCheck": true,
                            "VpcId": "vpc-xxxxxx",
                            "Description": "",
                            "NetworkInterfaceId": "eni-xxxx",
                            "PrivateIpAddresses": [
                                {
                                    "PrivateDnsName": "ip-xx.ap-south-1.compute.internal",
                                    "PrivateIpAddress": "xx.31.3.xxx",
                                    "Primary": true,
                                    "Association": {
                                        "PublicIp": "xx.127.24.xxx",
                                        "PublicDnsName": "ec2-xx.ap-south-1.compute.amazonaws.com",
                                        "IpOwnerId": "xxxxx"
                                    }
                                }
                            ],
                            "PrivateDnsName": "ip-xxx-31-3-xxx.ap-south-1.compute.internal",
                            "Attachment": {
                                "Status": "attached",
                                "DeviceIndex": 0,
                                "DeleteOnTermination": true,
                                "AttachmentId": "xxx",
                                "AttachTime": "20xx-xx-30Txx:16:xx.000Z"
                            },
                            "Groups": [
                                {
                                    "GroupName": "xxxx",
                                    "GroupId": "sg-xxxxx"
                                }
                            ],
                            "Ipv6Addresses": [],
                            "OwnerId": "xxxx",
                            "PrivateIpAddress": "xx.xx.xx.xxx",
                            "SubnetId": "subnet-xx",
                            "Association": {
                                "PublicIp": "xx.xx.xx.xxx",
                                "PublicDnsName": "ec2-xx.ap-south-1.compute.amazonaws.com",
                                "IpOwnerId": "xxxx"
                            }
                        }
                    ],
                    "SourceDestCheck": true,
                    "Placement": {
                        "Tenancy": "default",
                        "GroupName": "",
                        "AvailabilityZone": "xx"
                    },
                    "Hypervisor": "xxx",
                    "BlockDeviceMappings": [
                        {
                            "DeviceName": "/dev/xxx",
                            "Ebs": {
                                "Status": "attached",
                                "DeleteOnTermination": true,
                                "VolumeId": "vol-xxx",
                                "AttachTime": "20xxx-xx-xxTxx:16:xx.000Z"
                            }
                        }
                    ],
                    "Architecture": "x86_64",
                    "RootDeviceType": "ebs",
                    "RootDeviceName": "/dev/xxx",
                    "VirtualizationType": "xxx",
                    "Tags": [
                        {
                            "Value": "xxxx centxx",
                            "Key": "Name"
                        }
                    ],
                    "AmiLaunchIndex": 0
                }
            ],
            "ReservationId": "r-xxxx",
            "Groups": [],
            "OwnerId": "xxxxx"
        }
    ]
}

निम्नलिखित बैश स्क्रिप्ट वह stop-ec2.shहै /home/centos/cron-scripts/जो इस SO पोस्ट से प्रेरित है

(instance=$(aws ec2 describe-instances | jq '.Reservations[].Instances | select(.[].Tags[].Value | startswith("Appname Prod") ) |  select(.[].Tags[].Key == "Appname") |  {InstanceId: .[].InstanceId, PublicDnsName: .[].PublicDnsName, State: .[].State, LaunchTime: .[].LaunchTime, Tags: .[].Tags}  | [.]' | jq -r .[].InstanceId) && aws ec2 stop-instances --instance-ids ${instance} )

फ़ाइल का उपयोग करके चलाएं sh /home/centos/cron-scripts/stop-ec2.shऔर सत्यापित करें कि EC2 उदाहरण बंद हो जाता है। चलाने के लिए डिबग करें aws ec2 describe-instances | jq '.Reservations[].Instances | select(.[].Tags[].Value | startswith("Appname Prod") ) | select(.[].Tags[].Key == "Appname") | {InstanceId: .[].InstanceId, PublicDnsName: .[].PublicDnsName, State: .[].State, LaunchTime: .[].LaunchTime, Tags: .[].Tags} | [.]' | jq -r .[].InstanceIdऔर देखें कि यह सही इंस्टेंस आईडी देता है जिसे टैग किया गया है।

फिर crontab -eनिम्नलिखित पंक्ति में जोड़ा जा सकता है

30 14 * * * sh /home/centos/cron-scripts/stop-ec2.sh >> /tmp/stop

जो आउटपुट को लॉग इन करेगा /tmp/stop। 30 14 * * *यूटीसी क्रॉन अभिव्यक्ति है कि आप में जाँच कर सकते हैं है https://crontab.guru/। इसी तरह से बदलने के साथ aws ec2 start-instancesएक उदाहरण शुरू हो सकता है।

Question 14

मेरा मानना है कि शुरुआती सवाल थोड़ा भ्रमित करने वाला था। यह इस बात पर निर्भर करता है कि पास्ता को क्या चाहिए: 1. पंच / टर्मिनेट (इंस्टा स्टोर) - ऑटो स्केलिंग सही समाधान है (नेकेडिबेल का उत्तर) 2.स्टार्ट / स्टॉप ईबीएस बूट उदाहरण - ऑटो स्केलिंग से मदद नहीं मिलेगी, मैं दूरस्थ अनुसूचित स्क्रिप्ट का उपयोग करता हूं (यानी , ec2 सीएलआई)।

Question 15

आप इसे स्वचालित रूप से नहीं कर सकते हैं, या कम से कम कुछ प्रोग्रामिंग और स्क्रिप्ट फ़ाइलों में एपीआई हेरफेर के बिना नहीं। यदि आप अपनी छवियों को रोकने, फिर से शुरू करने और प्रबंधित करने के लिए एक विश्वसनीय समाधान चाहते हैं (संभवतः आपके वातावरण में लागतों को नियंत्रित करने के लिए) तो आप LabSlice को देखना चाह सकते हैं । अस्वीकरण: मैं इस कंपनी के लिए काम करता हूं।