אוטומציה של תשתית עבור יישומים ללא Serverform

מחשוב Serverless שינה את האופן שבו קבוצות לבנות ופרוסות יישומים, מציעות תמחור, תשלום-שימושי, והפחיתו את השימוש התפעולי על פני ראש הממשלה, עם זאת, הפעלת יישומים ללא שרת בייצור כרוכה הרבה יותר מקוד הפונקציה של כתיבת קוד.אתה צריך לספק ולנהל עשרות משאבי ענן -API Gateways, תורים, מסדי נתונים, תפקידי Terra World, הגדרות ורכיבי רשתות - כל אלה חייבים להיות משוכפלים באופן עקבי על פני פיתוח, במהירות, שיטות הפעלה כגון הגדרות הפעלה (תוכנות) וגרסאות הפעלה של כלי תצורה של כלי תצורה של כלי קידוד יעיל ביותר של קוד פתוח).

מה זה Terraform?

Terraform הוא כלי קוד פתוח IaC שנוצר על ידי HashiCorp המאפשר לך לספק ולנהל תשתיות על פני ספקי ענן מרובים באמצעות שפה תצורה מפוכחת המכונה HCL (השיקורפ שפה קוניגציה) במקום לכתוב תסריטים הכרחיים המבצעים פקודות שלב אחר צעד, אתה מצהיר על מצב הרצוי של תשתיות שלך - מה שאתה רוצה, תכונות שלהם, וכיצד הם מתייחסים זה לזה - ולהגיע פעולות הכרחיות כדי לקבוע את זה.

בלבה של טרהפור היא תוכנית ההוצאה להורג לפני ביצוע שינויים, טרהפור משווה את התצורה שלך נגד המצב הנוכחי של התשתית ומייצרת תוכנית מפורטת של מה ייברא, מעודכנת או מושמדתת.תוכנית זו ניתן לבדוק (ו, ב צינורות CI /CD, שאושרו) לפני שהוא מיושם, נותן לך לולאה משוב בטוח המונעת שינויים לא מקודמים.

טרהפור תומכת במאות ספקים, כולל כל פלטפורמות ענן גדולות (AWS, Azure, Google Cloud), וכן שירותי SaaS כמו Cloudflare, Datadog ו- GitHub. forless Applications ב-AWS, בדרך כלל תשתמשו ב-FLT:0AWSFOFLT:1 כדי להגדיר פונקציות Lambda, APIs, DynamoDB, SQS, תורים של Cos, Come, Coams, כל שרתי תיבות של משתמשים.

מדוע יישומים ללא שרת זקוקים לתשתית כקוד

יישומים ללא שרת מורכבים משירותי קטנים, תכליתיים רבים, אשר מתקשרים באופן מסונכרן או מסונכרן.אדריכלות טיפוסית המונעת אירוע עשויה לכלול שער API שמקבל בקשות HTTP, הפונקציה Lambda לעבד אותם, שולחן דינמודיוני לאחסון תוצאות, ו תור SQS כדי לטבול עבודה עבור פונקציה מבה שנייה.

• (ב) ⁇ :0) , ⁇ : ⁇ : 1 (ב) , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
• [ה]משנת [ה]: [ה]לא [ה] [ה]] [ה]] [ה]] [ה]]] [ה'] [ה'] [ה']'[ה]']'[ה]']'[ה']'[ה']']'[ה']']''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
• (ב) אחרי אסון, צריך לשנות הכל מאפס, בתקווה שתזכור כל הגדרה.
• (ב) ,0) בזבוז זמן: ההרחבה 1 (FLT:1) באמצעות הקונסולה לכל משאב צורכת שעות כדי להיכנס ללוגיקה יישום.

IaC פותר בעיות אלה על ידי הפיכת תשתיות לתוכנה.כל שינוי הוא בקשה למשיכה.כל סביבה היא פריסה חוזרת וניתן לקרוע את כל האדריכלות שלך ונבנה מחדש תוך דקות.עבור יישומים ללא שרת, שבו הצעת הערך היא מהירות וזריזות, IaC אינה אופציונלית - היא הבסיס של זרימת עבודה אמינה.

היתרונות העיקריים של שימוש ב- Terraform עבור Serverless

בעוד שכל כלי IaC יכול לשמש לניהול תשתיות ללא שרת, Terraform מציעה יתרונות ברורים שמתאימים היטב לצרכים של קבוצות ללא שרת.

אוטומציה מלאה

טרהפור מטפלת לא רק במתן הוראה אלא גם לעדכן ולהשמיד משאבים.כאשר אתה צריך לשנות את גודל הזיכרון של תפקוד למנדה או את התכונה TTL של שולחן דינמודי, אתה פשוט לעדכן את התצורה ורץ:0 כאשר אתה נעשה עם משאב, אותו קוד שיצר אותו יהיה לנקות אותו.זה חשוב במיוחד בסביבות נבואה - כמו פריסה מקדימה עבור כל משיכת כל בקשה - שבו אתה יכול להרוס באופן אוטומטי ערימה מלאה.

ניהול תלות ברורה

ארכיטקטורות ללא שרת יש תלות מורכבת.תפקוד A Lambda תלוי תפקיד IAM, אשר עשוי להיות תלוי במדיניות, אשר עשוי להיות תלוי על שולחן דינמוDB ARN. Terraform בונה גרף משאבים מההצהרות שלך באופן אוטומטי קובע את הסדר הנכון של פעולות.זה יוצר משאבים לפני שהם מתייחסים והמתנה עבור תלות להיות זמין.

ריבוי סובלנות

באמצעות חללי עבודה של Terraform או מבנים ניהוליים, אתה יכול להשתמש באותה תצורה על פני סביבות מרובות עם ערכים משתנים שונים.תצורה של הפונקציה של למודה יכול להיות זהה על פני dev, staging, ייצור, למעט משתנים ספציפיים לסביבה כגון שמות שולחן, רמות יומן או הגדרות VPC. זה מבטיח כי תשתיות ייצור הוא בדיוק מה נבדק.

בקרת המדינה הגרפית

ניהול המדינה הוא דאגה קריטית. Terraform מאפשר לך לאחסן מדינה מרחוק ב backends כמו S3 (עם נעילת דינמודי, Terraform Cloud, או HashiCorp Consul. מדינה מרחוק מאפשר שיתוף פעולה צוות: מהנדסים מרובים יכולים ליישם בבטחה שינויים באותה תשתית ללא קונפליקט.

להתחיל עם Terraform עבור הגבלת Serverless Deployment

בואו נלך באמצעות הקמת יישום מלא ללא שרת באמצעות Terraform ב-AWS.הדוגמה שלנו תחשוף REST פשוט באמצעות ממשק API אשר גורם לתפקוד Lambda, אשר כותב נתונים בטבלה דינמודי.

Prerequisites

• טרהפור (Ratform:0) הורד 1
• חשבון AWS עם אישורים המוגדרים (באמצעות משתנים סביבתיים או FLT:1)
• Node.js מותקנת (ליצור את קוד Lambda)

פרויקט מבנה

serverless-terraform/
├── main.tf
├── variables.tf
├── outputs.tf
├── lambda/
│ └── index.js
└── terraform.tfvars

1.הופנה מהדף The Terraform Provider

ב-FLT:3 , להגדיר את ספק AWS ולקבוע את האזור:

terraform {
 required_providers {
 aws = {
 source = "hashicorp/aws"
 version = "~> 5.0"
 }
 }
 backend "s3" {
 bucket = "my-terraform-state-bucket"
 key = "serverless-app/terraform.tfstate"
 region = "us-east-1"
 dynamodb_table = "terraform-locks"
 }
}

provider "aws" {
 region = var.aws_region
}

2.ליצור תפקיד של לגדה

data "aws_iam_policy_document" "lambda_assume_role" {
 statement {
 actions = ["sts:AssumeRole"]
 principals {
 type = "Service"
 identifiers = ["lambda.amazonaws.com"]
 }
 }
}

resource "aws_iam_role" "lambda_exec" {
 name = "serverless-lambda-role"
 assume_role_policy = data.aws_iam_policy_document.lambda_assume_role.json
}

resource "aws_iam_policy" "lambda_dynamodb_policy" {
 name = "lambda-dynamodb-policy"
 policy = jsonencode({
 Version = "2012-10-17"
 Statement = [
 {
 Action = ["dynamodb:PutItem", "dynamodb:GetItem", "dynamodb:UpdateItem"]
 Effect = "Allow"
 Resource = aws_dynamodb_table.items.arn
 },
 {
 Action = ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"]
 Effect = "Allow"
 Resource = "*"
 }
 ]
 })
}

resource "aws_iam_role_policy_attachment" "lambda_policy_attach" {
 role = aws_iam_role.lambda_exec.name
 policy_arn = aws_iam_policy.lambda_dynamodb_policy.arn
}

שתף את ה-DudmoDB Table

resource "aws_dynamodb_table" "items" {
 name = "items"
 billing_mode = "PAY_PER_REQUEST"
 hash_key = "id"

 attribute {
 name = "id"
 type = "S"
 }

 tags = {
 Environment = var.environment
 }
}

4.חבילה ו- Deploy The Lambda function

ראשית, יצירת פונקציה פשוטה למודה ב-FLT 7:

exports.handler = async (event) => {
 const AWS = require('aws-sdk');
 const dynamodb = new AWS.DynamoDB.DocumentClient();
 const id = event.pathParameters.id;

 const params = {
 TableName: process.env.TABLE_NAME,
 Item: { id, timestamp: Date.now(), data: event.body }
 };

 await dynamodb.put(params).promise();

 return {
 statusCode: 200,
 body: JSON.stringify({ id })
 };
};

לאחר מכן, בתצורת ה- Terraform שלך, הפנה את קוד הפונקציה:

data "archive_file" "lambda_zip" {
 type = "zip"
 source_dir = "${path.module}/lambda"
 output_path = "${path.module}/lambda_function_payload.zip"
}

resource "aws_lambda_function" "api_handler" {
 filename = data.archive_file.lambda_zip.output_path
 function_name = "serverless-api-handler"
 role = aws_iam_role.lambda_exec.arn
 handler = "index.handler"
 runtime = "nodejs18.x"
 source_code_hash = data.archive_file.lambda_zip.output_base64sha256

 environment {
 variables = {
 TABLE_NAME = aws_dynamodb_table.items.name
 }
 }
}

5.החשוף את Lambda באמצעות ממשק API Gateway

resource "aws_api_gateway_rest_api" "api" {
 name = "serverless-api"
}

resource "aws_api_gateway_resource" "items" {
 rest_api_id = aws_api_gateway_rest_api.api.id
 parent_id = aws_api_gateway_rest_api.api.root_resource_id
 path_part = "items"
}

resource "aws_api_gateway_resource" "item" {
 rest_api_id = aws_api_gateway_rest_api.api.id
 parent_id = aws_api_gateway_resource.items.id
 path_part = "{id}"
}

resource "aws_api_gateway_method" "put_item" {
 rest_api_id = aws_api_gateway_rest_api.api.id
 resource_id = aws_api_gateway_resource.item.id
 http_method = "PUT"
 authorization = "NONE"
}

resource "aws_api_gateway_integration" "lambda" {
 rest_api_id = aws_api_gateway_rest_api.api.id
 resource_id = aws_api_gateway_resource.item.id
 http_method = aws_api_gateway_method.put_item.http_method
 integration_http_method = "POST"
 type = "AWS_PROXY"
 uri = aws_lambda_function.api_handler.invoke_arn
}

resource "aws_lambda_permission" "apigw" {
 statement_id = "AllowExecutionFromAPIGateway"
 action = "lambda:InvokeFunction"
 function_name = aws_lambda_function.api_handler.function_name
 principal = "apigateway.amazonaws.com"
 source_arn = "${aws_api_gateway_rest_api.api.execution_arn}/*/*"
}

resource "aws_api_gateway_deployment" "prod" {
 depends_on = [aws_api_gateway_integration.lambda]
 rest_api_id = aws_api_gateway_rest_api.api.id
 stage_name = "prod"
}

6. Define Outputs

ב-FLT:11 , לחשוף את נקודת ה- API:

output "api_endpoint" {
 value = "${aws_api_gateway_deployment.prod.invoke_url}/items/"
}

7. החל

terraform init
terraform plan
terraform apply

לאחר החלת, תוכל להעביר בקשה לנקודת הסיום עם גוף ג'ייסון.תפקידה של למודה כותב את הנתונים ל-DudmoDB.

פרויקטים של Terraform עבור Serverless

יישומים אמיתיים ללא שרת הם גדולים מדי עבור קובץ תצורה יחיד.אימוץ מבנה פרויקט מדרגי הוא קריטי.כאן הם דפוסים משותפים:

השתמש במודולים כדי לבודד את המרכיבים הניתנים להחלפה

מודולים Terraform מאפשרים לך לשתף משאבים ליחידות לוגיות.עבור השרתים, אתה יכול ליצור מודולים עבור:

• מודול הפונקציה הבסיסית Lambda (עם תפקיד IAM, הרשאות ענן בסיסיות, ו- VPC config)
• מודול שילוב API + Lambda
• מודול שולחן דינמימו-DB עם תכונות סטנדרטיות ואוטומטיות
• מודול תור SQS עם תורים מתים

ניתן לאחסן מודולים ב- Git repository שלך או שפורסם ל-FLT:0Terraform RegistryFLT:1 הם מפשטים תצורה ספציפית לסביבה: אתה מעדכן מודול עם משתנים שונים לסביבה.

בסביבה נפרדת עם מנהלים או סביבת עבודה

שתי גישות נפוצות קיימות לניהול סביבות:

• (ב) ויקרא י"ד: "בְּהִיא אִתָּבְתָּבְתָּבְתָּבְתָּבְתָּבָה" (בראשית כ"ד, ט)
• (FLT:0) מרחבי עבודה: FIRLT:1) השתמש בתכונה מבוססת-במרחב העבודה כדי ליצור מקרים של אותה תצורה. סביבת עבודה הם קלים יותר, אבל יכול להיות מבלבל כאשר הם מתמודדים עם קבוצות מרובות.

עבור רוב הקבוצות ללא השרת, הגישה המנהלית ברורה יותר כי היא עושה גבולות מפורשים בבסיס הקוד.

מדינה מרוחקת עם Locking

לעולם אל תאחסן את המדינה מקומית לפרויקטים של צוות. השתמש ב-S3 backend עם ה-DymoDB עם נעילה של דינמו-די.S.D.S3 מחזיק בתיק המדינה, ו-DymoDB מספק מנעולים עקביים כך שרק אחדFLT:20 פועל בזמן.דוגמה תצורה חוזרת של תצורה הוכח מוקדם יותר.להבטיח את ה-S3 דלי ו-DudmoDB נוצר מחוץ ל- Terraform (boostrap אותם עם תסריט נפרד או שימוש ב-Cloud-Ratformsform של ניהול המדינה).

ניהול סודות באופן מאובטח

יישומים ללא שרת דורשים לעתים קרובות סודות כמו סיסמאות מסד נתונים, מפתחות API, או JWT חתימה אסימונים.לעולם אל תקוד קשה אלה ב- Terraform configs. במקום זאת, השתמש:

• מנהל סודות AWS או SSM Parameter Store, בהתייחסות ל-FLT:21 או ל-FLT:22 מקורות נתונים
• ספקית Vault מביאה סודות דינמיים
• קבצים מוצפנים ספציפיים לסביבה (למשל, FLT:23) עם כלים כמו FLT:24).

שיטות יעילות עבור תשתיות אוטומטיות עם Terraform

כדי למקסם את האמינות ואת מהירות הצוות, בצע את שיטות מוכחות אלה:

שליטה בכל

כל תצורה של Terraform, כולל מודולים, יש לאחסן ב Git עם הודעות מטרות משמעותיות. Tag הודעות ולהשתמש סניפים עבור שינויים.זה מספק מסלול ביקורת מלא של מי ששינה את מה ומתי.

תמיד לרוץ תוכנית וביקורת

בפיתוח המקומי, תמיד לרוץ (FLT:25) לפני LT:26 CI /CD, דורש צעד אישור ידני עבור פריסות הייצור. Terraform Cloud ו Atlantis הם כלים פופולריים המשלבים תוכנית / גלגולי עבודה סבירים לתוך בקשות למשוך.

יישום CI /CD עבור תשתיות

תשתיות טיפול משתנות כמו קוד שינויים, השתמש בצנרת שפועלת ב- 27 ו-FLT:28 על בקשות למשוך, ולאחר מכן רץ רצף:29, ולאחר מיזוג - ריצה - ריצה:30 ללא שרת, אתה יכול להפעיל בדיקות אינטגרציה לאחר החל כדי לאמת כי נקודות קצה ה- API להגיב כראוי.

שימוש ב-FLT:31 ל- Drift Detection

גם עם CI /CD, מישהו יכול לשנות באופן ידני משאב באמצעות הקונסולה.לוח זמנים קבוע (למשל, לילה) כדי לזהות סחף ולהזהיר את הצוות.

בדוק את הקונפורציות של ה- Terraform

קוד תשתיות יחיד הוא אפשרי עם כלים כמו FLT:0TerratestFLT:1, ספריית Go שספין את משאבי הענן האמיתיים, מאמת את התנהגותם, ודמעות אותם למטה.עבור השרתים, אתה יכול לפרוס מחסניות בחשבונות מבחן מבודדים, להפעיל בדיקות HTTP נגד ה-API, ולאמת תכנים של טרה-DB.

השתמש במדיניות כקוד

תקנות תאימות ארגוניות באמצעות HashiCorp Sentinel (Cloud) או Open Policy Agent.לדוגמה, דורשות שלכל פונקציות Lambda יש X-Ray tracing מופעל, או למנוע טבלאות דינמוDB ציבוריות.

אתגרים ופתרונות

המדינה: Locking and Conflicts

כאשר חברי צוות מרובים מנהלים את ה-FLT:33 בו-זמנית, שחיתות המדינה יכולה להתרחש.פתרון: תמיד להשתמש בגיבוי התומכים לנעול (S3 + DynamoDB) ולעולם לא לרוץ FLT:34 ישירות מענפים מקבילים.

מספר גדול של פונקציות Lambda

ניהול 50+ Lambda פועל בתצורה יחידה הופך ללא נאמנות.פתרון: שימוש ב-FLT:35 או FLT:36 עם מפה של הגדרות פונקציה.טוב יותר, לארגן פונקציות לתצורה נפרדת של Terraform אשר חולק מקורות נתונים המדינה. לדוגמה, יצוא תצורה "core" מרכזי (שמות טבלת DynamoDB, תורי SQS URLs) כי מטה את הפונקציה פונקציות זרם באמצעות יבוא באמצעות תצורה של תצורה של תצורה של ייצוב באמצעות תצורה של תצורה של ייצוב באמצעות תצורה של תפוצה דרך ייצוב של תצורה של תצורה של תפוצה דרך תפוצה דרך תפוצה של תפוצה של תפוצה של תפוצה דרך תפוצה של תפוצה של תפוצה של תפוצה של תפוצה של תפוצה בין-FLT:37:

סדר ציות באדריכלות מורכבות

למרות ש- Terraform מטפל ברוב התלויים באופן אוטומטי, תלות מעגלית (למשל, שני שירותים המתייחסים זה לזה של ARNs) יכולים לגרום לבעיות.פתרון: לשבור את המחזור על ידי הצגת משאב שלישי (כמו נושא מרכזי SNS) או להשתמש בלוקים מפורשים FLT:38.עבור השרת, דפוס משותף הוא ליצור תפקידי IAM ופעולות בנפרד מפונקציות כדי למנוע מחזורים.

שינוי קוד Lambda

טרהפור מיועדת לתשתיות, לא לפריסת קוד יישומים ברציפות.ד.ד. גירסאות חדשות של Lambda על ידי יישום מחדש של Terraform בכל פעם הוא איטי ולא אידיאלי עבור קוד מהיר של קוד קידוד: להפריד את פריסת התשתית (המיוצרת פעם אחת לסביבה) מפריסת הקוד. השתמש ב- CI/CD כי עדכון תפקוד Lambda באמצעות ה- SDK או כלים כמו מסגרת Serverless, בעוד ש-Traformsuals סביב קוד פתוח, יש רק כדי להפעיל את הקוד החדש.

מסקנה

פריסת תשתיות אוטומטיות עם Terraform מביאה את אותה הקפדה לתשתיות ללא שרת כי צוותי תוכנה חלים על קוד יישום. על ידי הגדרת כל משאב בקבצי HCL מבוקרת גרסה, אתה מקבל פריסות חוזרות, ניהול שינויים בטוח, שבילי ביקורת מלאים. פרויקט טרהפורמב מאורגן היטב עם מודולים, מדינה מרחוק ו / אינטגרציה CI מאפשר לצוותים לנהל מאות פונקציות Lambda, נקודות API, ללא עומס נתונים או שקעים על הסביבה.

בעוד ארכיטקטורות ללא שרת ממשיכות לגדול במורכבות - עם זרימת עבודה מונחה אירוע, פונקציות שלב ותשתיות גלובליות התפשטו על פני אזורים רבים - החשיבות של IaC רק עולה. החל עם הדפוסים והדוגמאות במאמר זה, אתה יכול לבנות בסיס שמאזניע עם היישום שלך ואת הארגון שלך.ההשקעה העליונה בהפחתת תשתית השרת שלך משלם עבור עצמו פעמים רבות על שגיאות מופחתות, פריסה מהירה יותר, ואבטחה משופרת אשר נבדקת את הסביבה שלך.