எனது வாழ்நாள் முழுவதும் கிளவுட் ஃபார்மேஷனுடன் பணியாற்றுவதற்கான இந்த 6 பாடங்களைக் கற்றுக்கொண்டேன்.

உடன் வேலை செய்ய ஆரம்பித்தேன் மேக உருவாக்கம் 4 வருடங்களுக்கு முன். அப்போதிருந்து நான் நிறைய உள்கட்டமைப்புகளை உடைத்துள்ளேன், ஏற்கனவே தயாரிப்பில் இருந்தவை கூட. ஆனால் ஒவ்வொரு முறையும் நான் எதையாவது குழப்பும்போது, ​​​​நான் புதிதாக ஒன்றைக் கற்றுக்கொண்டேன். இந்த அனுபவத்தின் மூலம், நான் கற்றுக்கொண்ட சில முக்கியமான பாடங்களைப் பகிர்ந்து கொள்கிறேன்.

பாடம் 1: மாற்றங்களைப் பயன்படுத்துவதற்கு முன் அவற்றைச் சோதிக்கவும்

நான் வேலை செய்ய ஆரம்பித்த உடனேயே இந்தப் பாடத்தைக் கற்றுக்கொண்டேன் மேக உருவாக்கம். நான் சரியாக என்ன உடைத்தேன் என்பது எனக்கு நினைவில் இல்லை, ஆனால் நான் கட்டளையைப் பயன்படுத்தினேன் என்பதை நிச்சயமாக நினைவில் கொள்கிறேன் aws மேகக்கணிப்பு மேம்படுத்தல். இந்த கட்டளையானது வரிசைப்படுத்தப்படும் மாற்றங்களின் சரிபார்ப்பு இல்லாமல் டெம்ப்ளேட்டை உருட்டுகிறது. எல்லா மாற்றங்களையும் பயன்படுத்துவதற்கு முன் அவற்றை ஏன் சோதிக்க வேண்டும் என்பதற்கு எந்த விளக்கமும் தேவையில்லை என்று நினைக்கிறேன்.

இந்த தோல்விக்குப் பிறகு, நான் உடனடியாக மாறிவிட்டேன் பயன்படுத்தல் குழாய், புதுப்பிப்பு கட்டளையை கட்டளையுடன் மாற்றுகிறது உருவாக்க-மாற்ற-தொகுப்பு

# OPERATION is either "UPDATE" or "CREATE"
changeset_id=$(aws cloudformation create-change-set 
    --change-set-name "$CHANGE_SET_NAME" 
    --stack-name "$STACK_NAME" 
    --template-body "$TPL_PATH" 
    --change-set-type "$OPERATION" 
    --parameters "$PARAMETERS" 
    --output text 
    --query Id)

aws cloudformation wait 
    change-set-create-complete --change-set-name "$changeset_id"

ஒரு மாற்றம் உருவாக்கப்பட்டவுடன், அது ஏற்கனவே இருக்கும் அடுக்கில் எந்த விளைவையும் ஏற்படுத்தாது. புதுப்பிப்பு கட்டளையைப் போலன்றி, changeet அணுகுமுறை உண்மையான வரிசைப்படுத்தலைத் தூண்டாது. மாறாக, வரிசைப்படுத்துவதற்கு முன் நீங்கள் மதிப்பாய்வு செய்யக்கூடிய மாற்றங்களின் பட்டியலை இது உருவாக்குகிறது. aws கன்சோல் இடைமுகத்தில் ஏற்படும் மாற்றங்களை நீங்கள் பார்க்கலாம். ஆனால் உங்களால் முடிந்த அனைத்தையும் தானியக்கமாக்க விரும்பினால், அவற்றை CLI இல் சரிபார்க்கவும்:

# this command is presented only for demonstrational purposes.
# the real command should take pagination into account
aws cloudformation describe-change-set 
    --change-set-name "$changeset_id" 
    --query 'Changes[*].ResourceChange.{Action:Action,Resource:ResourceType,ResourceId:LogicalResourceId,ReplacementNeeded:Replacement}' 
    --output table

இந்த கட்டளை பின்வருவனவற்றைப் போன்ற வெளியீட்டை உருவாக்க வேண்டும்:

--------------------------------------------------------------------
|                         DescribeChangeSet                        |
+---------+--------------------+----------------------+------------+
| Action  | ReplacementNeeded  |      Resource        | ResourceId |
+---------+--------------------+----------------------+------------+
|  Modify | True               |  AWS::ECS::Cluster   |  MyCluster |
|  Replace| True               |  AWS::RDS::DBInstance|  MyDB      |
|  Add    | None               |  AWS::SNS::Topic     |  MyTopic   |
+---------+--------------------+----------------------+------------+

ஆக்‌ஷன் இருக்கும் இடத்தில் மாற்றங்களுக்கு சிறப்பு கவனம் செலுத்துங்கள் மாற்றவும், அழி அல்லது எங்கே மாற்றீடு தேவை - உண்மை. இவை மிகவும் ஆபத்தான மாற்றங்கள் மற்றும் பொதுவாக தகவல் இழப்புக்கு வழிவகுக்கும்.

மாற்றங்களை மதிப்பாய்வு செய்தவுடன், அவை பயன்படுத்தப்படலாம்

aws cloudformation execute-change-set --change-set-name "$changeset_id"

operation_lowercase=$(echo "$OPERATION" | tr '[:upper:]' '[:lower:]')
aws cloudformation wait "stack-${operation_lowercase}-complete" 
    --stack-name "$STACK_NAME"

பாடம் 2: நிலையான ஆதாரங்கள் மாற்றப்படுவதோ அல்லது அகற்றப்படுவதோ தடுக்க ஸ்டாக் கொள்கையைப் பயன்படுத்தவும்

சில நேரங்களில் மாற்றங்களைப் பார்ப்பது மட்டும் போதாது. நாம் அனைவரும் மனிதர்கள், நாம் அனைவரும் தவறு செய்கிறோம். நாங்கள் மாற்றங்களைப் பயன்படுத்தத் தொடங்கிய சிறிது நேரத்திலேயே, எனது குழு உறுப்பினர் அறியாமல் ஒரு வரிசைப்படுத்தலைச் செய்தார், இதன் விளைவாக தரவுத்தள புதுப்பிப்பு ஏற்பட்டது. சோதனைச் சூழலாக இருந்ததால் மோசமான எதுவும் நடக்கவில்லை.

எங்கள் ஸ்கிரிப்ட்கள் மாற்றங்களின் பட்டியலைக் காட்டி, உறுதிப்படுத்தும்படிக் கேட்டாலும், மாற்றங்களின் பட்டியல் திரையில் பொருந்தாத அளவுக்கு பெரியதாக இருந்ததால், மாற்றீடு தவிர்க்கப்பட்டது. சோதனைச் சூழலில் இது ஒரு சாதாரண புதுப்பிப்பு என்பதால், மாற்றங்களுக்கு அதிக கவனம் செலுத்தப்படவில்லை.

நீங்கள் மாற்றவோ அல்லது அகற்றவோ விரும்பாத ஆதாரங்கள் உள்ளன. இவை RDS தரவுத்தள நிகழ்வு அல்லது மீள் தேடல் கிளஸ்டர் போன்ற ஸ்டேட்ஃபுல் சேவைகளாகும். செயல்படும் செயல்பாட்டிற்கு அத்தகைய ஆதாரத்தை நீக்க வேண்டியிருந்தால், aws தானாகவே பயன்படுத்த மறுத்தால் நன்றாக இருக்கும். அதிர்ஷ்டவசமாக, கிளவுட் ஃபார்மேஷன் இதைச் செய்வதற்கான ஒரு உள்ளமைக்கப்பட்ட வழியைக் கொண்டுள்ளது. இது அடுக்குக் கொள்கை என்று அழைக்கப்படுகிறது, மேலும் இதைப் பற்றி மேலும் படிக்கலாம் ஆவணங்கள்:

STACK_NAME=$1
RESOURCE_ID=$2

POLICY_JSON=$(cat <<EOF
{
    "Statement" : [{
        "Effect" : "Deny",
        "Action" : [
            "Update:Replace",
            "Update:Delete"
        ],
        "Principal": "*",
        "Resource" : "LogicalResourceId/$RESOURCE_ID"
    }]
}
EOF
)

aws cloudformation set-stack-policy --stack-name "$STACK_NAME" 
    --stack-policy-body "$POLICY_JSON"

பாடம் 3: ரகசிய அளவுருக்கள் கொண்ட அடுக்கைப் புதுப்பிக்கும்போது UsePreviousValue ஐப் பயன்படுத்தவும்

நீங்கள் ஒரு RDS mysql நிறுவனத்தை உருவாக்கும் போது, ​​AWS க்கு நீங்கள் ஒரு MasterUsername மற்றும் MasterUserPassword ஐ வழங்க வேண்டும். மூலக் குறியீட்டில் ரகசியங்களை வைக்காமல் இருப்பது நல்லது என்பதாலும், எல்லாவற்றையும் தானியக்கமாக்க விரும்புவதாலும், நான் "ஸ்மார்ட் மெக்கானிசம்" ஒன்றைச் செயல்படுத்தினேன், அங்கு பயன்படுத்தப்படுவதற்கு முன்பு s3 இலிருந்து நற்சான்றிதழ்கள் பெறப்படும், மேலும் நற்சான்றிதழ்கள் கிடைக்கவில்லை என்றால், புதிய சான்றுகள் உருவாக்கப்படும் மற்றும் s3 இல் சேமிக்கப்படுகிறது.

இந்த நற்சான்றிதழ்கள் மேகக்கணி உருவாக்கம்-மாற்றம்-செட் கட்டளைக்கு அளவுருக்களாக அனுப்பப்படும். ஸ்கிரிப்டைப் பரிசோதிக்கும் போது, ​​s3க்கான இணைப்பு துண்டிக்கப்பட்டது, மேலும் எனது "ஸ்மார்ட் மெக்கானிசம்" அதை புதிய நற்சான்றிதழ்களை உருவாக்குவதற்கான சமிக்ஞையாகக் கருதியது.

நான் தயாரிப்பில் இந்த ஸ்கிரிப்டைப் பயன்படுத்தத் தொடங்கினால், இணைப்புச் சிக்கல் மீண்டும் ஏற்பட்டால், அது புதிய சான்றுகளுடன் அடுக்கைப் புதுப்பிக்கும். இந்த குறிப்பிட்ட வழக்கில், மோசமான எதுவும் நடக்காது. இருப்பினும், நான் இந்த அணுகுமுறையை கைவிட்டு, இன்னொன்றைப் பயன்படுத்தத் தொடங்கினேன், ஒரே ஒரு முறை மட்டுமே நற்சான்றிதழ்களை வழங்கினேன் - அடுக்கை உருவாக்கும் போது. பின்னர், அடுக்கைப் புதுப்பிக்க வேண்டியிருக்கும் போது, ​​அளவுருவின் ரகசிய மதிப்பைக் குறிப்பிடுவதற்குப் பதிலாக, நான் பயன்படுத்துவேன் UsePreviousValue=true:

aws cloudformation create-change-set 
    --change-set-name "$CHANGE_SET_NAME" 
    --stack-name "$STACK_NAME" 
    --template-body "$TPL_PATH" 
    --change-set-type "UPDATE" 
    --parameters "ParameterKey=MasterUserPassword,UsePreviousValue=true"

பாடம் 4: ரோல்பேக் உள்ளமைவைப் பயன்படுத்தவும்

நான் பணிபுரிந்த மற்றொரு குழு செயல்பாட்டைப் பயன்படுத்தியது மேக உருவாக்கம், அழைக்கப்பட்டது திரும்ப திரும்ப கட்டமைப்பு. நான் இதற்கு முன்பு அதைக் காணவில்லை, மேலும் இது எனது அடுக்குகளை வரிசைப்படுத்துவது இன்னும் குளிராக இருக்கும் என்பதை விரைவாக உணர்ந்தேன். கிளவுட் ஃபார்மேஷனைப் பயன்படுத்தி லாம்ப்டா அல்லது ECS க்கு எனது குறியீட்டை ஒவ்வொரு முறையும் பயன்படுத்துகிறேன்.

இது எவ்வாறு செயல்படுகிறது: நீங்கள் குறிப்பிடுகிறீர்கள் CloudWatch அலாரம் அளவுருவில் --rollback-configurationநீங்கள் ஒரு மாற்றத்தை உருவாக்கும் போது. பின்னர், நீங்கள் மாற்றங்களின் தொகுப்பைச் செயல்படுத்தும்போது, ​​குறைந்தபட்சம் ஒரு நிமிடமாவது அலாரத்தை aws கண்காணிக்கும். இந்த நேரத்தில் அலாரத்தின் நிலையை ALARM ஆக மாற்றினால், அது வரிசைப்படுத்தலைத் திரும்பப் பெறுகிறது.

கீழே ஒரு டெம்ப்ளேட் பகுதியின் எடுத்துக்காட்டு மேக உருவாக்கம்அதில் நான் உருவாக்குகிறேன் கிளவுட்வாட்ச் அலாரம், இது கிளவுட் பயனர் மெட்ரிக்கை கிளவுட் பதிவுகளில் உள்ள பிழைகளின் எண்ணிக்கையாகக் கண்காணிக்கும் (மெட்ரிக் மூலம் உருவாக்கப்படுகிறது மெட்ரிக் வடிகட்டி):

Resources:
  # this metric tracks number of errors in the cloudwatch logs. In this
  # particular case it's assumed logs are in json format and the error logs are
  # identified by level "error". See FilterPattern
  ErrorMetricFilter:
    Type: AWS::Logs::MetricFilter
    Properties:
      LogGroupName: !Ref LogGroup
      FilterPattern: !Sub '{$.level = "error"}'
      MetricTransformations:
      - MetricNamespace: !Sub "${AWS::StackName}-log-errors"
        MetricName: Errors
        MetricValue: 1
        DefaultValue: 0

  ErrorAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: !Sub "${AWS::StackName}-errors"
      Namespace: !Sub "${AWS::StackName}-log-errors"
      MetricName: Errors
      Statistic: Maximum
      ComparisonOperator: GreaterThanThreshold
      Period: 1 # 1 minute
      EvaluationPeriods: 1
      Threshold: 0
      TreatMissingData: notBreaching
      ActionsEnabled: yes

இப்போது அலாரம் என பயன்படுத்தலாம் திரும்பப்பெறு கருவிப்பெட்டியை இயக்கும் போது தூண்டுதல்:

ALARM_ARN=$1

ROLLBACK_TRIGGER=$(cat <<EOF
{
  "RollbackTriggers": [
    {
      "Arn": "$ALARM_ARN",
      "Type": "AWS::CloudWatch::Alarm"
    }
  ],
  "MonitoringTimeInMinutes": 1
}
EOF
)

aws cloudformation create-change-set 
    --change-set-name "$CHANGE_SET_NAME" 
    --stack-name "$STACK_NAME" 
    --template-body "$TPL_PATH" 
    --change-set-type "UPDATE" 
    --rollback-configuration "$ROLLBACK_TRIGGER"

பாடம் 5: டெம்ப்ளேட்டின் சமீபத்திய பதிப்பைப் பயன்படுத்துவதை உறுதிசெய்யவும்

கிளவுட் ஃபார்மேஷன் டெம்ப்ளேட்டின் சமீபத்திய பதிப்பை விட குறைவான பதிப்பை வரிசைப்படுத்துவது எளிது, ஆனால் அவ்வாறு செய்வது அதிக சேதத்தை ஏற்படுத்தும். இது எங்களுக்கு ஒருமுறை நடந்தது: ஒரு டெவலப்பர் Git இலிருந்து சமீபத்திய மாற்றங்களைத் தள்ளவில்லை மற்றும் அறியாமல் அடுக்கின் முந்தைய பதிப்பைப் பயன்படுத்தினார். இதன் விளைவாக, இந்த அடுக்கைப் பயன்படுத்திய பயன்பாட்டிற்கு வேலையில்லா நேரம் ஏற்பட்டது.

ஒரு காசோலையைச் சேர்ப்பது போன்ற எளிமையான ஒன்று, அதைச் செய்வதற்கு முன், கிளை புதுப்பித்த நிலையில் உள்ளதா என்பதைப் பார்ப்பது நன்றாக இருக்கும் (ஜிட் உங்கள் பதிப்புக் கட்டுப்பாட்டுக் கருவி என்று வைத்துக்கொள்வோம்):

git fetch
HEADHASH=$(git rev-parse HEAD)
UPSTREAMHASH=$(git rev-parse master@{upstream})

if [[ "$HEADHASH" != "$UPSTREAMHASH" ]] ; then
   echo "Branch is not up to date with origin. Aborting"
   exit 1
fi

பாடம் 6: சக்கரத்தை மீண்டும் கண்டுபிடிக்க வேண்டாம்

உடன் வரிசைப்படுத்துவது போல் தோன்றலாம் மேக உருவாக்கம் - அது எளிது. aws cli கட்டளைகளை செயல்படுத்தும் பாஷ் ஸ்கிரிப்ட்கள் உங்களுக்குத் தேவை.

4 ஆண்டுகளுக்கு முன்பு நான் aws cloudformation create-stack கட்டளை எனப்படும் எளிய ஸ்கிரிப்ட்களுடன் தொடங்கினேன். விரைவில் ஸ்கிரிப்ட் எளிமையாக இல்லை. கற்றுக்கொண்ட ஒவ்வொரு பாடமும் ஸ்கிரிப்டை மேலும் மேலும் சிக்கலாக்கியது. இது கடினமாக மட்டுமல்ல, பிழைகள் நிறைந்ததாகவும் இருந்தது.

நான் தற்போது ஒரு சிறிய தகவல் தொழில்நுட்பத் துறையில் பணிபுரிகிறேன். ஒவ்வொரு அணிக்கும் கிளவுட் ஃபார்மேஷன் அடுக்குகளை வரிசைப்படுத்த அதன் சொந்த வழி உள்ளது என்பதை அனுபவம் காட்டுகிறது. அதுவும் மோசமானது. அனைவரும் ஒரே அணுகுமுறையைக் கடைப்பிடித்தால் நல்லது. அதிர்ஷ்டவசமாக, கிளவுட் ஃபார்மேஷன் அடுக்குகளை வரிசைப்படுத்தவும் கட்டமைக்கவும் உங்களுக்கு உதவும் பல கருவிகள் உள்ளன.

இந்த பாடங்கள் தவறுகளைத் தவிர்க்க உதவும்.

ஆதாரம்: www.habr.com