Terraform 0.11 - Serverless Applications with AWS Lambda and API Gateway

AWS लैम्ब्डा और एपीआई गेटवे के साथ सर्वर रहित अनुप्रयोग




terraform

AWS लैम्ब्डा और एपीआई गेटवे के साथ सर्वर रहित अनुप्रयोग

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

"सर्वर रहित" वेब एप्लिकेशन चलाने का एक लोकप्रिय तरीका यह है कि AWS लैम्ब्डा में एक या एक से अधिक फ़ंक्शन के रूप में एप्लिकेशन की कार्यक्षमता को लागू किया जाए और फिर अमेज़ॅन एपीआई गेटवे का उपयोग करके सार्वजनिक खपत के लिए इनका पर्दाफाश किया जाए।

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

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

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

तैयारी

इस गाइड का पालन करने के लिए आपको AWS खाते की आवश्यकता होगी और Terraform स्थापित करने के लिए। अपने क्रेडेंशियल्स को कॉन्फ़िगर करें ताकि Terraform आपकी ओर से कार्य करने में सक्षम हो।

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

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

लैम्बडा फंक्शन पैकेज का निर्माण

AWS लैम्ब्डा एक फ़ंक्शन के कार्यान्वयन को फ़ंक्शन स्रोत कोड वाले संग्रह के रूप में प्रदान करने की अपेक्षा करता है और फ़ंक्शन को निष्पादित करने के लिए आवश्यक किसी भी अन्य स्टैटिक फ़ाइलें।

टेराफॉर्म एक बिल्ड टूल नहीं है, इसलिए टेराफॉर्म के साथ इसे तैनात करने से पहले एक अलग बिल्ड प्रक्रिया का उपयोग करके ज़िप फाइल तैयार की जानी चाहिए। एक वास्तविक एप्लिकेशन के लिए हम आपके निर्माण को CI सिस्टम के माध्यम से स्वचालित करने की सलाह देते हैं, जिसका काम किसी भी आवश्यक बिल्ड एक्शन (लाइब्रेरी इंस्टॉलेशन, संकलन इत्यादि) को चलाना है, एक निर्माण विरूपण साक्ष्य के रूप में परिनियोजन ज़िप फ़ाइल का उत्पादन करें, और फिर उस कलाकृति को अमेज़ॅन में अपलोड करें। S3 बाल्टी जिसमें से इसे तैनाती के लिए पढ़ा जाएगा।

इस ट्यूटोरियल के लिए हम इन बिल्ड चरणों को मैन्युअल रूप से निष्पादित करेंगे और एक बहुत ही सरल AWS लैम्ब्डा फ़ंक्शन का निर्माण करेंगे। example एक नई निर्देशिका बनाने से शुरू करें जिसका उपयोग संग्रह बनाने के लिए किया जाएगा, और इसमें एकल स्रोत फ़ाइल होगी। हम इस उदाहरण में जावास्क्रिप्ट रनटाइम का उपयोग करेंगे, इसलिए हमारी फ़ाइल को main.js कहा जाता है और इसमें निम्नलिखित स्रोत कोड होंगे:

'use strict';

exports.handler = function (event, context, callback) {
    var response = {
        statusCode: 200,
        headers: {
            'Content-Type': 'text/html; charset=utf-8',
        },
        body: "<p>Hello world!</p>",
    };
    callback(null, response);
};

ऊपर एपीआई गेटवे के साथ उपयोग के लिए सबसे सरल संभव लैम्बडा फ़ंक्शन है, एक हार्ड-कोडित "हैलो वर्ल्ड!" API गेटवे की अपेक्षा ऑब्जेक्ट संरचना में प्रतिक्रिया।

अपने कमांड प्रॉम्प्ट से, उस फाइल वाली डायरेक्टरी में बदलाव करें और पैरेंट डायरेक्टरी में जिप फाइल में जोड़ें:

$ cd example
$ zip ../example.zip main.js
  adding: main.js (deflated 33%)
$ cd ..

एक वास्तविक निर्माण और परिनियोजन परिदृश्य में, हमारे संग्रह के मंचन के लिए हमारे पास एक S3 बाल्टी सेट होगी और इसका उपयोग वे निर्माण और परिनियोजन प्रक्रिया के बीच इन कलाकृतियों को "हैंड ऑफ" करने के लिए करेंगे। इस ट्यूटोरियल के लिए हम AWS CLI का उपयोग करके एक अस्थायी S3 बाल्टी बनाएंगे। S3 बाल्टी नाम विश्व स्तर पर अद्वितीय हैं, इसलिए आपको निम्नलिखित उदाहरण में --bucket= तर्क बदलने और इस ट्यूटोरियल के बाकी हिस्सों में अपने नए बाल्टी नाम को स्थानापन्न करने की आवश्यकता हो सकती है।

$ aws s3api create-bucket --bucket=terraform-serverless-example --region=us-east-1

अब आप अपनी निर्माण कलाकृतियों को इस S3 बाल्टी में अपलोड कर सकते हैं:

$ aws s3 cp example.zip s3://terraform-serverless-example/v1.0.0/example.zip

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

लैम्बडा फंक्शन बनाना

स्रोत कोड विरूपण साक्ष्य के साथ निर्मित और S3 पर अपलोड किया गया है, अब हम इसे तैनात करने के लिए अपना टेराफॉर्म कॉन्फ़िगरेशन लिख सकते हैं। एक नई निर्देशिका में, lambda.tf नाम की एक फाइल lambda.tf जिसमें निम्न विन्यास हो:

provider "aws" {
  region = "us-east-1"
}

resource "aws_lambda_function" "example" {
  function_name = "ServerlessExample"

  # The bucket name as created earlier with "aws s3api create-bucket"
  s3_bucket = "terraform-serverless-example"
  s3_key    = "v1.0.0/example.zip"

  # "main" is the filename within the zip file (main.js) and "handler"
  # is the name of the property under which the handler function was
  # exported in that file.
  handler = "main.handler"
  runtime = "nodejs6.10"

  role = "${aws_iam_role.lambda_exec.arn}"
}

# IAM role which dictates what other AWS services the Lambda function
# may access.
resource "aws_iam_role" "lambda_exec" {
  name = "serverless_example_lambda"

  assume_role_policy = <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": "sts:AssumeRole",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Effect": "Allow",
      "Sid": ""
    }
  ]
}
EOF
}

प्रत्येक लैम्ब्डा फ़ंक्शन में एक संबद्ध IAM भूमिका होनी चाहिए जो यह निर्धारित करती है कि इसकी अन्य AWS सेवाओं तक क्या पहुँच है। उपरोक्त कॉन्फ़िगरेशन नो एक्सेस पॉलिसी के साथ एक भूमिका निर्दिष्ट करता है, जो प्रभावी रूप से फ़ंक्शन को किसी भी एडब्ल्यूएस सेवाओं तक पहुंच नहीं देता है, क्योंकि हमारे उदाहरण के आवेदन के लिए ऐसी किसी भी एक्सेस की आवश्यकता नहीं है।

इससे पहले कि आप एक नई कॉन्फ़िगरेशन डायरेक्टरी के साथ काम कर सकें, इसे terraform init का उपयोग करके आरंभ किया जाना चाहिए, जो इस स्थिति में AWS को स्थापित करेगा:

$ terraform init

Initializing provider plugins...
- Checking for available provider plugins on https://releases.hashicorp.com...
- Downloading plugin for provider "aws" (1.9.0)...

# ...

Terraform has been successfully initialized!

# ...

अब हमेशा की तरह विन्यास लागू करें:

$ terraform apply

# ....

aws_iam_role.lambda_exec: Creating...
  arn:                   "" => "<computed>"
  assume_role_policy:    "" => "{\n  \"Version\": \"2012-10-17\",\n  \"Statement\": [\n    {\n      \"Action\": \"sts:AssumeRole\",\n      \"Principal\": {\n        \"Service\": \"lambda.amazonaws.com\"\n      },\n      \"Effect\": \"Allow\",\n      \"Sid\": \"\"\n    }\n  ]\n}\n"
  create_date:           "" => "<computed>"
  force_detach_policies: "" => "false"
  name:                  "" => "serverless_example_lambda"
  path:                  "" => "/"
  unique_id:             "" => "<computed>"
aws_iam_role.lambda_exec: Creation complete after 1s (ID: serverless_example_lambda)
aws_lambda_function.example: Creating...
  arn:              "" => "<computed>"
  function_name:    "" => "ServerlessExample"
  handler:          "" => "main.handler"
  invoke_arn:       "" => "<computed>"
  last_modified:    "" => "<computed>"
  memory_size:      "" => "128"
  publish:          "" => "false"
  qualified_arn:    "" => "<computed>"
  role:             "" => "arn:aws:iam::123456:role/serverless_example_lambda"
  runtime:          "" => "nodejs6.10"
  s3_bucket:        "" => "terraform-serverless-example"
  s3_key:           "" => "v1.0.0/example.zip"
  source_code_hash: "" => "<computed>"
  timeout:          "" => "3"
  tracing_config.#: "" => "<computed>"
  version:          "" => "<computed>"
aws_lambda_function.example: Still creating... (10s elapsed)
aws_lambda_function.example: Creation complete after 11s (ID: ServerlessExample)

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

फ़ंक्शन सफलतापूर्वक बनने के बाद, AWS CLI का उपयोग करके इसे लागू करने का प्रयास करें:

$ aws lambda invoke --region=us-east-1 --function-name=ServerlessExample output.txt
{"StatusCode": 200}
$ cat output.txt
{
  "statusCode":200,
  "headers":{
    "Content-Type":"text/html; charset=utf-8"
  },
  "body":"<p>Hello world!</p>"
}

अपेक्षित रूप से कार्य करने के साथ, अगला कदम एपीआई गेटवे रीस्ट एपीआई बनाना है जो इसे एक्सेस प्रदान करेगा।

एपीआई गेटवे को कॉन्फ़िगर करना

एपीआई गेटवे का नाम REST API के लिए सार्वजनिक-सामने वाले दृश्य के रूप में अपने मूल उद्देश्य को दर्शाता है, लेकिन बाद में इसे उन सुविधाओं के साथ बढ़ाया गया, जो AWS लैंबडा पर आधारित संपूर्ण वेब अनुप्रयोग को उजागर करना आसान बनाते हैं। इस ट्यूटोरियल में बाद में इन सुविधाओं का उपयोग किया जाएगा। "रेस्ट एपीआई" शब्द का उपयोग इस तरह से किया जाता है, क्योंकि एपीआई गेटवे आवश्यक रूप से एक एपीआई की सेवा के बजाय एक सामान्य एचटीटीपी दृश्यपटल के रूप में कार्य कर रहा है।

पिछले चरण से हमारे lambda.tf के समान निर्देशिका में एक नई फ़ाइल api_gateway.tf बनाएं। सबसे पहले, रूट "REST API" ऑब्जेक्ट को निम्नानुसार कॉन्फ़िगर करें:

resource "aws_api_gateway_rest_api" "example" {
  name        = "ServerlessExample"
  description = "Terraform Serverless Application Example"
}

"REST API" हमारे द्वारा बनाए गए अन्य API गेटवे ऑब्जेक्ट्स के सभी के लिए कंटेनर है।

एपीआई गेटवे के लिए आने वाले सभी अनुरोधों को एक कॉन्फ़िगर किए गए संसाधन और विधि के साथ मेल खाना चाहिए। एक एकल प्रॉक्सी संसाधन को परिभाषित करने के लिए lambda.tf फ़ाइल में निम्नलिखित जोड़ें:

resource "aws_api_gateway_resource" "proxy" {
  rest_api_id = "${aws_api_gateway_rest_api.example.id}"
  parent_id   = "${aws_api_gateway_rest_api.example.root_resource_id}"
  path_part   = "{proxy+}"
}

resource "aws_api_gateway_method" "proxy" {
  rest_api_id   = "${aws_api_gateway_rest_api.example.id}"
  resource_id   = "${aws_api_gateway_resource.proxy.id}"
  http_method   = "ANY"
  authorization = "NONE"
}

विशेष path_part मान "{proxy+}" प्रॉक्सी व्यवहार को सक्रिय करता है, जिसका अर्थ है कि यह संसाधन किसी भी अनुरोध पथ से मेल खाएगा। इसी तरह, aws_api_gateway_method ब्लॉक "ANY" http_method "ANY" http_method का उपयोग करता है, जो किसी भी अनुरोध विधि का उपयोग करने की अनुमति देता है। एक साथ लिया गया, इसका मतलब है कि आने वाले सभी अनुरोध इस संसाधन से मेल खाएंगे।

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

resource "aws_api_gateway_integration" "lambda" {
  rest_api_id = "${aws_api_gateway_rest_api.example.id}"
  resource_id = "${aws_api_gateway_method.proxy.resource_id}"
  http_method = "${aws_api_gateway_method.proxy.http_method}"

  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = "${aws_lambda_function.example.invoke_arn}"
}

AWS_PROXY एकीकरण प्रकार API गेटवे को किसी अन्य AWS सेवा के API में कॉल करने का कारण बनता है। इस मामले में, यह AWS लैंबडा एपीआई को लैंबडा फ़ंक्शन का "आह्वान" बनाने के लिए बुलाएगा।

दुर्भाग्य से प्रॉक्सी संसाधन एपीआई की जड़ में एक खाली रास्ते से मेल नहीं खा सकता है। इसे संभालने के लिए, एक समान कॉन्फ़िगरेशन को रूट संसाधन पर लागू किया जाना चाहिए जो REST API ऑब्जेक्ट के लिए बनाया गया है:

resource "aws_api_gateway_method" "proxy_root" {
  rest_api_id   = "${aws_api_gateway_rest_api.example.id}"
  resource_id   = "${aws_api_gateway_rest_api.example.root_resource_id}"
  http_method   = "ANY"
  authorization = "NONE"
}

resource "aws_api_gateway_integration" "lambda_root" {
  rest_api_id = "${aws_api_gateway_rest_api.example.id}"
  resource_id = "${aws_api_gateway_method.proxy_root.resource_id}"
  http_method = "${aws_api_gateway_method.proxy_root.http_method}"

  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = "${aws_lambda_function.example.invoke_arn}"
}

अंत में, आपको कॉन्फ़िगरेशन को सक्रिय करने और परीक्षण के लिए उपयोग किए जा सकने वाले URL पर API को उजागर करने के लिए API गेटवे "परिनियोजन" बनाने की आवश्यकता है:

resource "aws_api_gateway_deployment" "example" {
  depends_on = [
    "aws_api_gateway_integration.lambda",
    "aws_api_gateway_integration.lambda_root",
  ]

  rest_api_id = "${aws_api_gateway_rest_api.example.id}"
  stage_name  = "test"
}

उपरोक्त सभी कॉन्फ़िगरेशन परिवर्तन के साथ, इन नए ऑब्जेक्ट को बनाने के लिए रन terraform apply फिर से terraform apply हैं:

$ terraform apply

# ...

aws_api_gateway_rest_api.example: Creating...
  created_date:     "" => "<computed>"
  description:      "" => "Terraform Serverless Application Example"
  name:             "" => "ServerlessExample"
  root_resource_id: "" => "<computed>"
aws_api_gateway_rest_api.example: Creation complete after 1s (ID: bkqhuuz8r8)

# ...etc, etc...

Apply complete! Resources: 5 added, 0 changed, 0 destroyed.

निर्माण के चरण पूरे होने के बाद, नई वस्तुएँ एपीआई गेटवे कंसोल में दिखाई देंगी।

लैम्ब्डा फ़ंक्शन के साथ एकीकरण अभी तक कार्यात्मक नहीं है क्योंकि एपीआई गेटवे में फ़ंक्शन को लागू करने के लिए आवश्यक पहुंच नहीं है। अगला चरण इसे संबोधित करेगा, जिससे एप्लिकेशन पूरी तरह कार्यात्मक हो जाएगा।

पहुँच के लिए एपीआई गेटवे की अनुमति देना

डिफ़ॉल्ट रूप से किसी भी दो एडब्ल्यूएस सेवाओं की एक दूसरे तक पहुंच नहीं है, जब तक कि पहुंच स्पष्ट रूप से प्रदान नहीं की जाती है। लैम्ब्डा कार्यों के लिए, aws_lambda_permission संसाधन का उपयोग करके दी गई है, जिसे पहले चरण में बनाई गई lambda.tf फ़ाइल में जोड़ा जाना चाहिए:

resource "aws_lambda_permission" "apigw" {
  statement_id  = "AllowAPIGatewayInvoke"
  action        = "lambda:InvokeFunction"
  function_name = "${aws_lambda_function.example.arn}"
  principal     = "apigateway.amazonaws.com"

  # The /*/* portion grants access from any method on any resource
  # within the API Gateway "REST API".
  source_arn = "${aws_api_gateway_deployment.example.execution_arn}/*/*"
}

निर्मित एपीआई का परीक्षण करने के लिए आपको इसके परीक्षण URL तक पहुंचने की आवश्यकता होगी। इसे एक्सेस करना आसान बनाने के लिए, api_gateway.tf निम्न आउटपुट जोड़ें:

output "base_url" {
  value = "${aws_api_gateway_deployment.example.invoke_url}"
}

terraform apply साथ नवीनतम परिवर्तन terraform apply :

$ terraform apply

# ...

aws_lambda_permission.apigw: Creating...
  statement_id:  "" => "AllowAPIGatewayInvoke"
  action:        "" => "lambda:InvokeFunction"
  function_name: "" => "ServerlessExample"
# ...
aws_lambda_permission.apigw: Creation complete after 1s

Apply complete! Resources: 1 added, 0 changed, 1 destroyed.

Outputs:

base_url = https://bkqhuuz8r8.execute-api.us-east-1.amazonaws.com/test

आउटपुट में दिए गए URL को अपने पसंदीदा वेब ब्राउज़र में अपने रन से लोड करें। अगर सब कुछ काम कर गया है, तो आप "हैलो दुनिया!" पाठ देखेंगे। यह संदेश एपीआई गेटवे एंडपॉइंट के माध्यम से पहले अपलोड किए गए लंबोदा फंक्शन कोड से लौटाया जा रहा है।

यह एक अच्छा मील का पत्थर है! आवेदन का पहला संस्करण तैनात और सुलभ है। आगे हम देखेंगे कि एप्लिकेशन के नए संस्करण को कैसे तैनात किया जाए।

लैम्बडा फंक्शन का एक नया संस्करण

किसी भी वास्तविक आवेदन के लिए समय के साथ अनिवार्य रूप से आवेदन कोड में बदलाव होगा, जिसे तब पिछले संस्करण के स्थान पर AWS लाम्बा में तैनात किया जाना चाहिए।

पहले से main.js वाले example निर्देशिका में main.js , संदेश को बदलने के लिए स्रोत कोड अपडेट करें। उदाहरण के लिए:

'use strict';

exports.handler = function (event, context, callback) {
    var response = {
        statusCode: 200,
        headers: {
            'Content-Type': 'text/html; charset=utf-8',
        },
        body: "<p>Bonjour au monde!</p>",
    };
    callback(null, response);
};

ज़िप फ़ाइल को अपडेट करें और विरूपण साक्ष्य S3 बाल्टी में एक नया संस्करण अपलोड करें:

$ cd example
$ zip ../example.zip main.js
updating: main.js (deflated 33%)
$ cd ..
$ aws s3 cp example.zip s3://terraform-serverless-example/v1.0.1/example.zip

ध्यान दें कि S3 ऑब्जेक्ट पथ में एक अलग संस्करण संख्या का उपयोग किया गया था, इसलिए पिछले संग्रह को बरकरार रखा गया है। संस्करणों के बीच आसान स्विचिंग की अनुमति देने के लिए आप एक चर को परिभाषित कर सकते हैं ताकि संस्करण संख्या को गतिशील रूप से चुना जा सके। निम्नलिखित को lambda.tf जोड़ें:

variable "app_version" {
}

फिर पहले परिभाषित aws_lambda_function संसाधन का पता aws_lambda_function और संस्करण चर को शामिल करने के लिए अपने s3_key तर्क को बदलें:

resource "aws_lambda_function" "example" {
  function_name = "ServerlessExample"

  # The bucket name as created earlier with "aws s3api create-bucket"
  s3_bucket = "terraform-serverless-example"
  s3_key    = "v${var.app_version}/example.zip"

  # (leave the remainder unchanged)
}

terraform apply कमांड को अब एक संस्करण संख्या प्रदान करने की आवश्यकता है:

$ terraform apply -var="app_version=1.0.1"

# ...

Terraform will perform the following actions:

  ~ aws_lambda_function.example
      s3_key: "v1.0.0/example.zip" => "v1.0.1/example.zip"

Plan: 0 to add, 1 to change, 0 to destroy.

# ...

परिवर्तन लागू होने के बाद, फिर से परीक्षण URL पर जाएं और आपको अद्यतन ग्रीटिंग संदेश देखना चाहिए।

पुराने संस्करण पर वापस जाना

कभी-कभी नया कोड अपेक्षित रूप से काम नहीं करता है और सबसे सरल मार्ग पिछले संस्करण में वापस आना है। क्योंकि कलाकृतियों के सभी ऐतिहासिक संस्करण S3 पर संरक्षित हैं, मूल संस्करण को एक ही आदेश के साथ पुनर्स्थापित किया जा सकता है:

$ terraform apply -var="app_version=1.0.0"

यह आवेदन पूर्ण होने के बाद, परीक्षण URL मूल संदेश को फिर से लौटाएगा।

निष्कर्ष

इस मार्गदर्शिका में आपने AWS लैंबडा फ़ंक्शन बनाया, जो अमेज़ॅन एपीआई गेटवे प्रॉक्सी संसाधनों के साथ संगत परिणाम देता है और फिर एपीआई गेटवे कॉन्फ़िगर किया गया है।

यद्यपि इस गाइड में उपयोग किया जाने वाला AWS लैंबडा फ़ंक्शन बहुत सरल है, लेकिन अधिक व्यावहारिक अनुप्रयोगों में एपीआई गेटवे प्रॉक्सी का अनुरोध करने के लिए हेल्पर लाइब्रेरीज़ का उपयोग करना संभव है, जो विभिन्न भाषाओं में मानक HTTP एप्लिकेशन APIs जैसे पायथन के WSGI या NodeJS एक्सप्रेस फ्रेमवर्क के लिए है

जब एक CI सिस्टम में चलने वाली स्वचालित निर्माण प्रक्रिया के साथ संयुक्त किया जाता है, तो Terraform अनुप्रयोगों को AWS लाम्बा कार्यों के रूप में तैनात करने में मदद कर सकता है, लगातार भंडारण के लिए अन्य AWS सेवाओं के साथ जुड़ने के लिए उपयुक्त IAM नीतियां, रहस्यों तक पहुंच आदि।

सफाई करना

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

$ terraform destroy -var="app_version=0.0.0"

चूँकि विरूपण साक्ष्य ज़िप फाइलें और S3 बाल्टी ही टेराफॉर्म के बाहर बनाई गई थी, इसलिए उन्हें टेराफॉर्म के बाहर भी साफ किया जाना चाहिए। यह S3 कंसोल के माध्यम से किया जा सकता है। ध्यान दें कि बाल्टी में सभी वस्तुओं को हटा दिया जाना चाहिए इससे पहले कि बाल्टी खुद को हटा दी जाए।

आगे की पढाई

निम्न टेराफॉर्म संसाधन प्रकार इस ट्यूटोरियल में उपयोग किए जाते हैं:

प्रत्येक संसाधन प्रकार का संदर्भ पृष्ठ इसके सभी समर्थित तर्कों और निर्यातित विशेषताओं पर पूर्ण विवरण प्रदान करता है।

कस्टम डोमेन नाम और टीएलएस प्रमाणपत्र

उदाहरण के लिए, यह गाइड एपीआई गेटवे द्वारा डिफ़ॉल्ट रूप से पेश किए गए परीक्षण URL का उपयोग करता है। व्यवहार में, अधिकांश एप्लिकेशन एक कस्टम होस्टनाम पर तैनात किए जाएंगे।

एक कस्टम डोमेन नाम का उपयोग करने के लिए आपको पहले उस डोमेन को पंजीकृत करना होगा और इसके लिए DNS होस्टिंग को कॉन्फ़िगर करना होगा। आपको या तो अमेज़ॅन सर्टिफिकेट मैनेजर सर्टिफिकेट बनाना होगा या टीएलएस सर्टिफिकेट को थर्ड-पार्टी सर्टिफिकेट अथॉरिटी में पंजीकृत कराना होगा।

डोमेन नाम को कॉन्फ़िगर करना इस ट्यूटोरियल के दायरे से परे है, लेकिन यदि आपके पास पहले से ही एक होस्टनाम और टीएलएस प्रमाणपत्र है, जिसका आप उपयोग करना चाहते हैं, तो आप इसे एपीआई गेटवे के साथ aws_api_gateway_domain_name संसाधन प्रकार का उपयोग करके पंजीकृत कर सकते हैं।

एक पंजीकृत डोमेन नाम तब aws_api_gateway_base_path_mapping का उपयोग करके किसी विशेष "REST API" ऑब्जेक्ट पर मैप किया जाता है। कॉन्फ़िगर किया गया डोमेन नाम तब किसी विशेष परिनियोजन चरण के लिए अन्य नाम बन जाता है।

एपीआई गेटवे कॉन्फ़िगरेशन में परिवर्तन करना

यह मार्गदर्शिका एक एकल संसाधन के साथ एक बहुत ही सरल एपीआई गेटवे कॉन्फ़िगरेशन बनाती है जो सभी अनुरोधों को एक ही गंतव्य से गुजरती है। अपग्रेड के चरण तब केवल AWS लैंबडा फ़ंक्शन को संशोधित करते हैं, जिससे एपीआई गेटवे कॉन्फ़िगरेशन अपरिवर्तित रहता है।

API गेटवे के चरणबद्ध परिनियोजन मॉडल के कारण, यदि आपको API गेटवे कॉन्फ़िगरेशन में परिवर्तन करने की आवश्यकता है, तो आपको स्पष्ट रूप से अनुरोध करना चाहिए कि यह तैनाती संसाधन "टेनिंग" द्वारा फिर से तैनात किया जाए:

$ terraform taint aws_api_gateway_deployment.example

यह कमांड फ़्लैग करता है कि इस ऑब्जेक्ट को अगली टेराफ़ॉर्म योजना में फिर से बनाया जाना चाहिए, इसलिए एक बाद में terraform apply होगा, फिर तैनाती को बदल देगा और इस तरह नवीनतम कॉन्फ़िगरेशन परिवर्तनों को सक्रिय करेगा।

कृपया ध्यान दें कि यह "पुनः परिनियोजन" कुछ डाउनटाइम का कारण होगा, क्योंकि टेराफॉर्म को फिर से बनाने से पहले चरण और संबंधित तैनाती को हटाने की आवश्यकता होगी। टेराफॉर्म के बाहर एपीआई गेटवे कंसोल के माध्यम से तैनाती कार्रवाई को ट्रिगर करके डाउनटाइम से बचा जा सकता है। इस गाइड में शामिल दृष्टिकोण जानबूझकर इस सीमा को कम करने के लिए समय के साथ एपीआई गेटवे कॉन्फ़िगरेशन को संशोधित करने की आवश्यकता को कम करता है। इस वर्कफ़्लो के लिए बेहतर समर्थन Terraform के AWS प्रदाता को भविष्य के रिलीज़ में जोड़ा जाएगा।