പുലുമിക്കൊപ്പം അടിസ്ഥാന സൗകര്യങ്ങൾ കോഡായി പരിശോധിക്കുന്നു. ഭാഗം 1

ഗുഡ് ആഫ്റ്റർനൂൺ സുഹൃത്തുക്കളെ. നിരക്കിൽ ഒരു പുതിയ ഒഴുക്കിന്റെ ആരംഭം പ്രതീക്ഷിച്ച് "DevOps പ്രാക്ടീസുകളും ടൂളുകളും" ഞങ്ങൾ നിങ്ങളുമായി ഒരു പുതിയ വിവർത്തനം പങ്കിടുന്നു. പോകൂ.

ഇൻഫ്രാസ്ട്രക്ചർ കോഡിനായി പുലുമിയും പൊതു-ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷകളും ഉപയോഗിക്കുന്നത് (ഇൻഫ്രാസ്ട്രക്ചർ കോഡായി) നിരവധി ഗുണങ്ങൾ നൽകുന്നു: കഴിവുകളുടെയും അറിവിന്റെയും ലഭ്യത, അമൂർത്തതയിലൂടെ കോഡിലെ ബോയിലർപ്ലേറ്റ് ഇല്ലാതാക്കൽ, നിങ്ങളുടെ ടീമിന് പരിചിതമായ ഉപകരണങ്ങൾ, ഐഡിഇകൾ, ലിന്ററുകൾ എന്നിവ. ഈ സോഫ്‌റ്റ്‌വെയർ എഞ്ചിനീയറിംഗ് ഉപകരണങ്ങളെല്ലാം ഞങ്ങളെ കൂടുതൽ ഉൽപ്പാദനക്ഷമമാക്കുക മാത്രമല്ല, ഞങ്ങളുടെ കോഡിന്റെ ഗുണനിലവാരം മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. അതിനാൽ, പൊതു-ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ഉപയോഗം മറ്റൊരു പ്രധാന സോഫ്‌റ്റ്‌വെയർ ഡെവലപ്‌മെന്റ് പ്രാക്ടീസ് അവതരിപ്പിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നത് സ്വാഭാവികമാണ് - പരിശോധന.

ഈ ലേഖനത്തിൽ, ഞങ്ങളുടെ ഇൻഫ്രാസ്ട്രക്ചർ കോഡ് ആയി പരീക്ഷിക്കാൻ പുലുമി ഞങ്ങളെ എങ്ങനെ സഹായിക്കുന്നുവെന്ന് നോക്കാം.

എന്തുകൊണ്ടാണ് അടിസ്ഥാന സൗകര്യങ്ങൾ പരീക്ഷിക്കുന്നത്?

വിശദാംശങ്ങളിലേക്ക് പോകുന്നതിനുമുമ്പ്, “എന്തുകൊണ്ടാണ് അടിസ്ഥാന സൗകര്യങ്ങൾ പരീക്ഷിക്കുന്നത്?” എന്ന ചോദ്യം ചോദിക്കുന്നത് മൂല്യവത്താണ്. ഇതിന് നിരവധി കാരണങ്ങളുണ്ട്, അവയിൽ ചിലത് ഇതാ:

• നിങ്ങളുടെ പ്രോഗ്രാം ലോജിക്കിന്റെ വ്യക്തിഗത ഫംഗ്‌ഷനുകളുടെയോ ശകലങ്ങളുടെയോ യൂണിറ്റ് പരിശോധന
• ചില നിയന്ത്രണങ്ങൾക്കെതിരെ അടിസ്ഥാന സൗകര്യത്തിന്റെ ആവശ്യമുള്ള അവസ്ഥ പരിശോധിക്കുന്നു.
• ഒരു സ്റ്റോറേജ് ബക്കറ്റിന്റെ എൻക്രിപ്ഷന്റെ അഭാവം അല്ലെങ്കിൽ സുരക്ഷിതമല്ലാത്ത, ഇന്റർനെറ്റിൽ നിന്ന് വെർച്വൽ മെഷീനുകളിലേക്കുള്ള തുറന്ന ആക്സസ് പോലുള്ള സാധാരണ പിശകുകൾ കണ്ടെത്തൽ.
• അടിസ്ഥാന സൗകര്യങ്ങൾ ഒരുക്കുന്നതിന്റെ നടത്തിപ്പ് പരിശോധിക്കുന്നു.
• പ്രൊവിഷനിംഗിനു ശേഷമുള്ള പ്രവർത്തനക്ഷമത പരിശോധിക്കുന്നതിനായി നിങ്ങളുടെ "പ്രോഗ്രാം ചെയ്ത" ഇൻഫ്രാസ്ട്രക്ചറിനുള്ളിൽ പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷൻ ലോജിക്കിന്റെ റൺടൈം ടെസ്റ്റിംഗ് നടത്തുന്നു.
• നമുക്ക് കാണാനാകുന്നതുപോലെ, ഇൻഫ്രാസ്ട്രക്ചർ ടെസ്റ്റിംഗ് ഓപ്ഷനുകളുടെ വിശാലമായ ശ്രേണി ഉണ്ട്. ഈ സ്പെക്‌ട്രത്തിലെ ഓരോ പോയിന്റിലും പരിശോധിക്കാനുള്ള സംവിധാനങ്ങൾ പോലുമിയിലുണ്ട്. നമുക്ക് ആരംഭിച്ച് ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നോക്കാം.

യൂണിറ്റ് പരിശോധന

ജാവാസ്ക്രിപ്റ്റ്, പൈത്തൺ, ടൈപ്പ്സ്ക്രിപ്റ്റ് അല്ലെങ്കിൽ ഗോ പോലുള്ള പൊതു-ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷകളിലാണ് പുലുമി പ്രോഗ്രാമുകൾ എഴുതിയിരിക്കുന്നത്. അതിനാൽ, പരീക്ഷണ ചട്ടക്കൂടുകൾ ഉൾപ്പെടെയുള്ള ഉപകരണങ്ങളും ലൈബ്രറികളും ഉൾപ്പെടെ ഈ ഭാഷകളുടെ മുഴുവൻ ശക്തിയും അവർക്ക് ലഭ്യമാണ്. പുലുമി ഒരു മൾട്ടി-ക്ലൗഡാണ്, അതായത് ഏത് ക്ലൗഡ് ദാതാവിൽ നിന്നും ഇത് പരിശോധിക്കാൻ ഉപയോഗിക്കാം.

(ഈ ലേഖനത്തിൽ, ബഹുഭാഷയും മൾട്ടിക്ലൗഡും ആണെങ്കിലും, ഞങ്ങൾ ജാവാസ്ക്രിപ്റ്റും മോച്ചയും ഉപയോഗിക്കുന്നു കൂടാതെ AWS-ൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. നിങ്ങൾക്ക് പൈത്തൺ ഉപയോഗിക്കാം. unittest, ടെസ്റ്റ് ചട്ടക്കൂട്, അല്ലെങ്കിൽ നിങ്ങൾ ഇഷ്ടപ്പെടുന്ന മറ്റേതെങ്കിലും ടെസ്റ്റ് ഫ്രെയിംവർക്ക് പോകുക. തീർച്ചയായും, പുലുമി അസൂർ, ഗൂഗിൾ ക്ലൗഡ്, കുബർനെറ്റസ് എന്നിവയിൽ മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നു.)

ഞങ്ങൾ കണ്ടതുപോലെ, നിങ്ങളുടെ ഇൻഫ്രാസ്ട്രക്ചർ കോഡ് പരീക്ഷിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നതിന് നിരവധി കാരണങ്ങളുണ്ട്. അതിലൊന്നാണ് പരമ്പരാഗത യൂണിറ്റ് ടെസ്റ്റിംഗ്. കാരണം നിങ്ങളുടെ കോഡിന് ഫംഗ്‌ഷനുകൾ ഉണ്ടായിരിക്കാം - ഉദാഹരണത്തിന്, CIDR കണക്കാക്കാൻ, പേരുകൾ, ടാഗുകൾ മുതലായവ ചലനാത്മകമായി കണക്കാക്കുക. - നിങ്ങൾ ഒരുപക്ഷേ അവരെ പരീക്ഷിക്കാൻ ആഗ്രഹിച്ചേക്കാം. നിങ്ങളുടെ പ്രിയപ്പെട്ട പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ആപ്ലിക്കേഷനുകൾക്കായി സാധാരണ യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുന്നതിന് സമാനമാണിത്.
കുറച്ചുകൂടി സങ്കീർണ്ണമാക്കുന്നതിന്, നിങ്ങളുടെ പ്രോഗ്രാം വിഭവങ്ങൾ എങ്ങനെ അനുവദിക്കുന്നുവെന്ന് നിങ്ങൾക്ക് പരിശോധിക്കാം. ദൃഷ്ടാന്തീകരിക്കുന്നതിന്, നമുക്ക് ഒരു ലളിതമായ EC2 സെർവർ സൃഷ്ടിക്കേണ്ടതുണ്ടെന്ന് സങ്കൽപ്പിക്കുക, ഇനിപ്പറയുന്നവയിൽ ഞങ്ങൾക്ക് ഉറപ്പുണ്ടായിരിക്കണം:

• സംഭവങ്ങൾക്ക് ഒരു ടാഗ് ഉണ്ട് Name.
• സന്ദർഭങ്ങൾ ഇൻലൈൻ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കരുത് userData - നമ്മൾ ഒരു AMI (ചിത്രം) ഉപയോഗിക്കണം.
• ഇൻറർനെറ്റിൽ ഒരു എസ്എസ്എച്ച് ഉണ്ടായിരിക്കരുത്.

ഈ ഉദാഹരണം അടിസ്ഥാനമാക്കിയുള്ളതാണ് എന്റെ ഉദാഹരണം aws-js-webserver:

index.js:

"use strict";
 
let aws = require("@pulumi/aws");
 
let group = new aws.ec2.SecurityGroup("web-secgrp", {
    ingress: [
        { protocol: "tcp", fromPort: 22, toPort: 22, cidrBlocks: ["0.0.0.0/0"] },
        { protocol: "tcp", fromPort: 80, toPort: 80, cidrBlocks: ["0.0.0.0/0"] },
    ],
});
 
let userData =
`#!/bin/bash
echo "Hello, World!" > index.html
nohup python -m SimpleHTTPServer 80 &`;
 
let server = new aws.ec2.Instance("web-server-www", {
    instanceType: "t2.micro",
    securityGroups: [ group.name ], // reference the group object above
    ami: "ami-c55673a0"             // AMI for us-east-2 (Ohio),
    userData: userData              // start a simple web server
});
 
exports.group = group;
exports.server = server;
exports.publicIp = server.publicIp;
exports.publicHostName = server.publicDns;

ഇതാണ് അടിസ്ഥാന പുലുമി പ്രോഗ്രാം: ഇത് ഒരു EC2 സുരക്ഷാ ഗ്രൂപ്പും ഒരു ഉദാഹരണവും അനുവദിക്കുന്നു. എന്നിരുന്നാലും, മുകളിൽ പറഞ്ഞിരിക്കുന്ന മൂന്ന് നിയമങ്ങളും ഞങ്ങൾ ഇവിടെ ലംഘിക്കുന്നു എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. നമുക്ക് പരീക്ഷ എഴുതാം!

പരീക്ഷകൾ എഴുതുന്നു

ഞങ്ങളുടെ ടെസ്റ്റുകളുടെ പൊതുവായ ഘടന സാധാരണ മോച്ച ടെസ്റ്റുകൾ പോലെ കാണപ്പെടും:

ec2tests.js

test.js:
let assert = require("assert");
let mocha = require("mocha");
let pulumi = require("@pulumi/pulumi");
let infra = require("./index");
 
describe("Infrastructure", function() {
    let server = infra.server;
    describe("#server", function() {
        // TODO(check 1): Должен быть тэг Name.
        // TODO(check 2): Не должно быть inline-скрипта userData.
    });
    let group = infra.group;
    describe("#group", function() {
        // TODO(check 3): Не должно быть SSH, открытого в Интернет.
    });
});

ഇനി നമുക്ക് ആദ്യത്തെ ടെസ്റ്റ് എഴുതാം: സംഭവങ്ങൾക്ക് ടാഗ് ഉണ്ടെന്ന് ഉറപ്പാക്കുക Name. ഇത് പരിശോധിക്കാൻ നമുക്ക് EC2 ഇൻസ്റ്റൻസ് ഒബ്ജക്റ്റ് ലഭിക്കുകയും അനുബന്ധ പ്രോപ്പർട്ടി പരിശോധിക്കുകയും ചെയ്യുക tags:

 // check 1: Должен быть тэг Name.
        it("must have a name tag", function(done) {
            pulumi.all([server.urn, server.tags]).apply(([urn, tags]) => {
                if (!tags || !tags["Name"]) {
                    done(new Error(`Missing a name tag on server ${urn}`));
                } else {
                    done();
                }
            });
        });

ഇത് ഒരു സാധാരണ ടെസ്റ്റ് പോലെ കാണപ്പെടുന്നു, എന്നാൽ ശ്രദ്ധിക്കേണ്ട ചില സവിശേഷതകൾ:

• വിന്യാസത്തിന് മുമ്പ് ഞങ്ങൾ ഒരു റിസോഴ്സിന്റെ അവസ്ഥ അന്വേഷിക്കുന്നതിനാൽ, ഞങ്ങളുടെ ടെസ്റ്റുകൾ എല്ലായ്പ്പോഴും "പ്ലാൻ" (അല്ലെങ്കിൽ "പ്രിവ്യൂ") മോഡിൽ പ്രവർത്തിക്കുന്നു. അതിനാൽ, മൂല്യങ്ങൾ വീണ്ടെടുക്കുകയോ നിർവചിക്കപ്പെടുകയോ ചെയ്യാത്ത നിരവധി ഗുണങ്ങളുണ്ട്. നിങ്ങളുടെ ക്ലൗഡ് ദാതാവ് കണക്കാക്കിയ എല്ലാ ഔട്ട്‌പുട്ട് പ്രോപ്പർട്ടികൾ ഇതിൽ ഉൾപ്പെടുന്നു. ഇത് ഞങ്ങളുടെ ടെസ്റ്റുകൾക്ക് സാധാരണമാണ് - ഇൻപുട്ട് ഡാറ്റ മാത്രമാണ് ഞങ്ങൾ പരിശോധിക്കുന്നത്. ഇന്റഗ്രേഷൻ ടെസ്റ്റുകളുടെ കാര്യം വരുമ്പോൾ ഞങ്ങൾ പിന്നീട് ഈ പ്രശ്നത്തിലേക്ക് മടങ്ങും.
• എല്ലാ പുലുമി റിസോഴ്‌സ് പ്രോപ്പർട്ടികളും ഔട്ട്‌പുട്ടുകൾ ആയതിനാൽ, അവയിൽ പലതും അസമന്വിതമായി വിലയിരുത്തപ്പെടുന്നതിനാൽ, മൂല്യങ്ങൾ ആക്‌സസ് ചെയ്യുന്നതിന് ഞങ്ങൾ പ്രയോഗിക്കുന്ന രീതി ഉപയോഗിക്കേണ്ടതുണ്ട്. ഇത് വാഗ്ദാനങ്ങളോടും പ്രവർത്തനങ്ങളോടും വളരെ സാമ്യമുള്ളതാണ് then .
• പിശക് സന്ദേശത്തിൽ ഉറവിട URN കാണിക്കുന്നതിന് ഞങ്ങൾ നിരവധി പ്രോപ്പർട്ടികൾ ഉപയോഗിക്കുന്നതിനാൽ, ഞങ്ങൾ ഫംഗ്ഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട് pulumi.allഅവരെ സംയോജിപ്പിക്കാൻ.
• അവസാനമായി, ഈ മൂല്യങ്ങൾ അസമന്വിതമായി കണക്കാക്കുന്നതിനാൽ, ഞങ്ങൾ മോച്ചയുടെ ബിൽറ്റ്-ഇൻ അസിൻക് കോൾബാക്ക് സവിശേഷത ഉപയോഗിക്കേണ്ടതുണ്ട് done അല്ലെങ്കിൽ ഒരു വാഗ്ദാനം തിരികെ നൽകുന്നു.

ഞങ്ങൾ എല്ലാം സജ്ജീകരിച്ചുകഴിഞ്ഞാൽ, ലളിതമായ JavaScript മൂല്യങ്ങളായി ഞങ്ങൾക്ക് ഇൻപുട്ടുകളിലേക്ക് ആക്സസ് ലഭിക്കും. സ്വത്ത് tags ഒരു ഭൂപടമാണ് (അസോസിയേറ്റീവ് അറേ), അതിനാൽ ഇത് (1) തെറ്റല്ലെന്നും (2) ഇതിനായി ഒരു കീ ഉണ്ടെന്നും ഞങ്ങൾ ഉറപ്പാക്കും Name. ഇത് വളരെ ലളിതമാണ്, ഇപ്പോൾ നമുക്ക് എന്തും പരീക്ഷിക്കാം!

ഇനി നമുക്ക് രണ്ടാമത്തെ ചെക്ക് എഴുതാം. ഇത് ഇതിലും ലളിതമാണ്:

 // check 2: Не должно быть inline-скрипта userData.
        it("must not use userData (use an AMI instead)", function(done) {
            pulumi.all([server.urn, server.userData]).apply(([urn, userData]) => {
                if (userData) {
                    done(new Error(`Illegal use of userData on server ${urn}`));
                } else {
                    done();
                }
            });
        });

അവസാനമായി, നമുക്ക് മൂന്നാമത്തെ പരീക്ഷ എഴുതാം. സുരക്ഷാ ഗ്രൂപ്പുമായി ബന്ധപ്പെട്ട ലോഗിൻ നിയമങ്ങൾക്കായി ഞങ്ങൾ തിരയുന്നതിനാൽ ഇത് കുറച്ചുകൂടി സങ്കീർണ്ണമായിരിക്കും, അവയിൽ പലതും ഉണ്ടാകാം, കൂടാതെ ആ നിയമങ്ങളിലെ CIDR ശ്രേണികൾ, അവയിൽ പലതും ഉണ്ടാകാം. എന്നാൽ ഞങ്ങൾ കൈകാര്യം ചെയ്തു:

    // check 3: Не должно быть SSH, открытого в Интернет.
        it("must not open port 22 (SSH) to the Internet", function(done) {
            pulumi.all([ group.urn, group.ingress ]).apply(([ urn, ingress ]) => {
                if (ingress.find(rule =>
                        rule.fromPort == 22 && rule.cidrBlocks.find(block =>
                            block === "0.0.0.0/0"))) {
                    done(new Error(`Illegal SSH port 22 open to the Internet (CIDR 0.0.0.0/0) on group ${urn}`));
                } else {
                    done();
                }
            });
        });

അത്രയേയുള്ളൂ. ഇനി നമുക്ക് ടെസ്റ്റുകൾ നടത്താം!

പരിശോധനകൾ നടത്തുന്നു

മിക്ക കേസുകളിലും, നിങ്ങൾക്ക് ഇഷ്ടമുള്ള ടെസ്റ്റ് ചട്ടക്കൂട് ഉപയോഗിച്ച് സാധാരണ രീതിയിൽ ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കാം. എന്നാൽ പുലുമിയുടെ ഒരു പ്രത്യേകത ശ്രദ്ധിക്കേണ്ടതാണ്.
സാധാരണയായി, പുലുമി പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന്, പുലിമി സിഎൽഐ (കമാൻഡ് ലൈൻ ഇന്റർഫേസ്) ഉപയോഗിക്കുന്നു, ഇത് ഭാഷാ റൺടൈം ക്രമീകരിക്കുന്നു, പുലുമി എഞ്ചിന്റെ വിക്ഷേപണം നിയന്ത്രിക്കുന്നു, അതുവഴി ഉറവിടങ്ങളുള്ള പ്രവർത്തനങ്ങൾ റെക്കോർഡുചെയ്യാനും പ്ലാനിൽ ഉൾപ്പെടുത്താനും കഴിയും. എന്നിരുന്നാലും, ഒരു പ്രശ്നമുണ്ട്. നിങ്ങളുടെ ടെസ്റ്റ് ചട്ടക്കൂടിന്റെ നിയന്ത്രണത്തിൽ പ്രവർത്തിക്കുമ്പോൾ, CLI-യും പുലുമി എഞ്ചിനും തമ്മിൽ ആശയവിനിമയം ഉണ്ടാകില്ല.

ഈ പ്രശ്നം പരിഹരിക്കാൻ, ഞങ്ങൾ ഇനിപ്പറയുന്നവ വ്യക്തമാക്കേണ്ടതുണ്ട്:

• പരിസ്ഥിതി വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്ന പദ്ധതിയുടെ പേര് PULUMI_NODEJS_PROJECT (അല്ലെങ്കിൽ, കൂടുതൽ പൊതുവായി, PULUMI__PROJECT для других языков).
  പരിസ്ഥിതി വേരിയബിളിൽ വ്യക്തമാക്കിയ സ്റ്റാക്കിന്റെ പേര് PULUMI_NODEJS_STACK (അല്ലെങ്കിൽ, കൂടുതൽ പൊതുവായി, PULUMI__ STACK).
  നിങ്ങളുടെ സ്റ്റാക്ക് കോൺഫിഗറേഷൻ വേരിയബിളുകൾ. ഒരു പരിസ്ഥിതി വേരിയബിൾ ഉപയോഗിച്ച് അവ ലഭിക്കും PULUMI_CONFIG കീ/മൂല്യം ജോഡികളുള്ള JSON മാപ്പാണ് അവയുടെ ഫോർമാറ്റ്.

  എക്സിക്യൂഷൻ സമയത്ത് CLI/എഞ്ചിനിലേക്കുള്ള കണക്ഷൻ ലഭ്യമല്ലെന്ന് സൂചിപ്പിക്കുന്ന മുന്നറിയിപ്പുകൾ പ്രോഗ്രാം നൽകും. ഇത് പ്രധാനമാണ്, കാരണം നിങ്ങളുടെ പ്രോഗ്രാം യഥാർത്ഥത്തിൽ ഒന്നും വിന്യസിക്കില്ല, നിങ്ങൾ ചെയ്യാൻ ഉദ്ദേശിച്ചതല്ലെങ്കിൽ അത് അതിശയിപ്പിച്ചേക്കാം! നിങ്ങൾക്ക് വേണ്ടത് ഇതാണ് എന്ന് പുലുമിയോട് പറയാൻ, നിങ്ങൾക്ക് ഇൻസ്റ്റാൾ ചെയ്യാം PULUMI_TEST_MODE в true.

  പ്രോജക്റ്റ് നാമം വ്യക്തമാക്കേണ്ടതുണ്ടെന്ന് സങ്കൽപ്പിക്കുക my-ws, സ്റ്റാക്കിന്റെ പേര് dev, കൂടാതെ AWS മേഖലയും us-west-2. മോച്ച ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള കമാൻഡ് ലൈൻ ഇതുപോലെ കാണപ്പെടും:

  $ PULUMI_TEST_MODE=true 
      PULUMI_NODEJS_STACK="my-ws" 
      PULUMI_NODEJS_PROJECT="dev" 
      PULUMI_CONFIG='{ "aws:region": "us-west-2" }' 
      mocha tests.js

  പ്രതീക്ഷിച്ചതുപോലെ ഇത് ചെയ്യുന്നത്, ഞങ്ങൾക്ക് മൂന്ന് പരീക്ഷകളിൽ പരാജയപ്പെട്ടുവെന്ന് കാണിക്കും!

  Infrastructure
      #server
        1) must have a name tag
   	 2) must not use userData (use an AMI instead)
      #group
        3) must not open port 22 (SSH) to the Internet
  
    0 passing (17ms)
    3 failing
   
   1) Infrastructure
         #server
           must have a name tag:
       Error: Missing a name tag on server
          urn:pulumi:my-ws::my-dev::aws:ec2/instance:Instance::web-server-www
  
   2) Infrastructure
         #server
           must not use userData (use an AMI instead):
       Error: Illegal use of userData on server
          urn:pulumi:my-ws::my-dev::aws:ec2/instance:Instance::web-server-www
  
   3) Infrastructure
         #group
           must not open port 22 (SSH) to the Internet:
       Error: Illegal SSH port 22 open to the Internet (CIDR 0.0.0.0/0) on group

  നമുക്ക് നമ്മുടെ പ്രോഗ്രാം ശരിയാക്കാം:

  "use strict";
   
  let aws = require("@pulumi/aws");
   
  let group = new aws.ec2.SecurityGroup("web-secgrp", {
      ingress: [
          { protocol: "tcp", fromPort: 80, toPort: 80, cidrBlocks: ["0.0.0.0/0"] },
      ],
  });
   
  let server = new aws.ec2.Instance("web-server-www", {
      tags: { "Name": "web-server-www" },
      instanceType: "t2.micro",
      securityGroups: [ group.name ], // reference the group object above
      ami: "ami-c55673a0"             // AMI for us-east-2 (Ohio),
  });
   
  exports.group = group;
  exports.server = server;
  exports.publicIp = server.publicIp;
  exports.publicHostName = server.publicDns;
  

  തുടർന്ന് ടെസ്റ്റുകൾ വീണ്ടും പ്രവർത്തിപ്പിക്കുക:

  Infrastructure
      #server
        ✓ must have a name tag
        ✓ must not use userData (use an AMI instead)
      #group
        ✓ must not open port 22 (SSH) to the Internet
   
   
   3 passing (16ms)

  എല്ലാം നന്നായി നടന്നു... ഹൂറേ! ✓✓✓

  ഇന്നത്തേക്ക് അത്രയേയുള്ളൂ, എന്നാൽ വിവർത്തനത്തിന്റെ രണ്ടാം ഭാഗത്തിൽ ഞങ്ങൾ വിന്യാസ പരിശോധനയെക്കുറിച്ച് സംസാരിക്കും 😉

അവലംബം: www.habr.com