ನನ್ನ ಜೀವನದುದ್ದಕ್ಕೂ ಕ್ಲೌಡ್‌ಫಾರ್ಮೇಶನ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಈ 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"

ಒಮ್ಮೆ ಬದಲಾವಣೆಯನ್ನು ರಚಿಸಿದ ನಂತರ, ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸ್ಟಾಕ್ ಮೇಲೆ ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ಅಪ್‌ಡೇಟ್ ಆಜ್ಞೆಯಂತೆ, ಚೇಂಜ್‌ಸೆಟ್ ವಿಧಾನವು ನಿಜವಾದ ನಿಯೋಜನೆಯನ್ನು ಪ್ರಚೋದಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ನಿಯೋಜನೆಯ ಮೊದಲು ನೀವು ಪರಿಶೀಲಿಸಬಹುದಾದ ಬದಲಾವಣೆಗಳ ಪಟ್ಟಿಯನ್ನು ಇದು ರಚಿಸುತ್ತದೆ. ನೀವು 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 ಗೆ ಸಂಪರ್ಕವು ಕಳೆದುಹೋಗಿದೆ ಮತ್ತು ನನ್ನ "ಸ್ಮಾರ್ಟ್ ಮೆಕ್ಯಾನಿಸಂ" ಹೊಸ ರುಜುವಾತುಗಳನ್ನು ಉತ್ಪಾದಿಸುವ ಸಂಕೇತವಾಗಿ ಪರಿಗಣಿಸಿದೆ.

ನಾನು ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದರೆ ಮತ್ತು ಸಂಪರ್ಕದ ಸಮಸ್ಯೆ ಮತ್ತೆ ಸಂಭವಿಸಿದರೆ, ಅದು ಹೊಸ ರುಜುವಾತುಗಳೊಂದಿಗೆ ಸ್ಟಾಕ್ ಅನ್ನು ನವೀಕರಿಸುತ್ತದೆ. ಈ ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಕೆಟ್ಟದ್ದೇನೂ ಆಗುವುದಿಲ್ಲ. ಆದಾಗ್ಯೂ, ನಾನು ಈ ವಿಧಾನವನ್ನು ಕೈಬಿಟ್ಟೆ ಮತ್ತು ಇನ್ನೊಂದನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದೆ, ಒಮ್ಮೆ ಮಾತ್ರ ರುಜುವಾತುಗಳನ್ನು ಒದಗಿಸಿದೆ - ಸ್ಟಾಕ್ ಅನ್ನು ರಚಿಸುವಾಗ. ಮತ್ತು ನಂತರ, ಸ್ಟಾಕ್ ಅನ್ನು ನವೀಕರಿಸಬೇಕಾದಾಗ, ನಿಯತಾಂಕದ ರಹಸ್ಯ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸುವ ಬದಲು, ನಾನು ಸರಳವಾಗಿ ಬಳಸುತ್ತೇನೆ ಹಿಂದಿನ ಮೌಲ್ಯವನ್ನು ಬಳಸಿ=ನಿಜ:

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: ರೋಲ್‌ಬ್ಯಾಕ್ ಕಾನ್ಫಿಗರೇಶನ್ ಬಳಸಿ

ನಾನು ಕೆಲಸ ಮಾಡಿದ ಮತ್ತೊಂದು ತಂಡವು ಕಾರ್ಯವನ್ನು ಬಳಸಿದೆ ಮೇಘ ರಚನೆ, ಎಂದು ಕರೆಯುತ್ತಾರೆ ರೋಲ್ಬ್ಯಾಕ್ ಕಾನ್ಫಿಗರೇಶನ್. ನಾನು ಮೊದಲು ಅದನ್ನು ಕಂಡಿರಲಿಲ್ಲ ಮತ್ತು ನನ್ನ ಸ್ಟ್ಯಾಕ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವುದನ್ನು ಇನ್ನಷ್ಟು ತಂಪಾಗಿಸುತ್ತದೆ ಎಂದು ತ್ವರಿತವಾಗಿ ಅರಿತುಕೊಂಡೆ. ಈಗ ನಾನು ಕ್ಲೌಡ್ ಫಾರ್ಮೇಶನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಲ್ಯಾಂಬ್ಡಾ ಅಥವಾ ಇಸಿಎಸ್‌ಗೆ ನನ್ನ ಕೋಡ್ ಅನ್ನು ನಿಯೋಜಿಸಿದಾಗಲೆಲ್ಲಾ ಅದನ್ನು ಬಳಸುತ್ತೇನೆ.

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ನೀವು ಸೂಚಿಸಿ 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 command ಎಂಬ ಸರಳ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿದೆ. ಶೀಘ್ರದಲ್ಲೇ ಸ್ಕ್ರಿಪ್ಟ್ ಇನ್ನು ಮುಂದೆ ಸರಳವಾಗಲಿಲ್ಲ. ಕಲಿತ ಪ್ರತಿಯೊಂದು ಪಾಠವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣಗೊಳಿಸಿತು. ಇದು ಕಷ್ಟ ಮಾತ್ರವಲ್ಲ, ದೋಷಗಳಿಂದ ಕೂಡಿದೆ.

ನಾನು ಪ್ರಸ್ತುತ ಸಣ್ಣ ಐಟಿ ವಿಭಾಗದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇನೆ. ಪ್ರತಿ ತಂಡವು ಕ್ಲೌಡ್ ಫಾರ್ಮೇಶನ್ ಸ್ಟ್ಯಾಕ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಲು ತನ್ನದೇ ಆದ ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ ಎಂದು ಅನುಭವವು ತೋರಿಸಿದೆ. ಮತ್ತು ಅದು ಕೆಟ್ಟದು. ಎಲ್ಲರೂ ಒಂದೇ ವಿಧಾನವನ್ನು ಅನುಸರಿಸಿದರೆ ಉತ್ತಮ. ಅದೃಷ್ಟವಶಾತ್, ಕ್ಲೌಡ್ ಫಾರ್ಮೇಶನ್ ಸ್ಟ್ಯಾಕ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಲು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಹಲವು ಉಪಕರಣಗಳು ಲಭ್ಯವಿವೆ.

ತಪ್ಪುಗಳನ್ನು ತಪ್ಪಿಸಲು ಈ ಪಾಠಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ.

ಮೂಲ: www.habr.com