పులుమితో కోడ్‌గా మౌలిక సదుపాయాలను పరీక్షిస్తోంది. 1 వ భాగము

శుభ మధ్యాహ్నం మిత్రులారా. రేటు వద్ద కొత్త ప్రవాహం ప్రారంభం ఊహించి "DevOps అభ్యాసాలు మరియు సాధనాలు" మేము మీతో కొత్త అనువాదాన్ని భాగస్వామ్యం చేస్తున్నాము. వెళ్ళండి.

ఇన్‌ఫ్రాస్ట్రక్చర్ కోడ్ (ఇన్‌ఫ్రాస్ట్రక్చర్‌గా కోడ్) కోసం పులుమి మరియు సాధారణ-ప్రయోజన ప్రోగ్రామింగ్ భాషలను ఉపయోగించడం అనేక ప్రయోజనాలను అందిస్తుంది: నైపుణ్యాలు మరియు జ్ఞానం యొక్క లభ్యత, సంగ్రహణ ద్వారా కోడ్‌లోని బాయిలర్‌ప్లేట్‌ను తొలగించడం, IDEలు మరియు లిన్టర్‌లు వంటి మీ బృందానికి తెలిసిన సాధనాలు. ఈ సాఫ్ట్‌వేర్ ఇంజినీరింగ్ సాధనాలన్నీ మమ్మల్ని మరింత ఉత్పాదకంగా మార్చడమే కాకుండా మా కోడ్ నాణ్యతను మెరుగుపరుస్తాయి. అందువల్ల, సాధారణ-ప్రయోజన ప్రోగ్రామింగ్ భాషల ఉపయోగం మరొక ముఖ్యమైన సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ ప్రాక్టీస్‌ను పరిచయం చేయడానికి అనుమతిస్తుంది - ఇది సహజం. పరీక్ష.

ఈ ఆర్టికల్‌లో, మా మౌలిక సదుపాయాలను కోడ్‌గా పరీక్షించడంలో పులుమి మాకు ఎలా సహాయపడుతుందో చూద్దాం.

మౌలిక సదుపాయాలను ఎందుకు పరీక్షించాలి?

వివరాల్లోకి వెళ్లే ముందు, “ఎందుకు మౌలిక సదుపాయాలను పరీక్షించాలి?” అనే ప్రశ్న అడగడం విలువ. దీనికి చాలా కారణాలు ఉన్నాయి మరియు వాటిలో కొన్ని ఇక్కడ ఉన్నాయి:

• మీ ప్రోగ్రామ్ లాజిక్ యొక్క వ్యక్తిగత విధులు లేదా శకలాల యూనిట్ పరీక్ష
• నిర్దిష్ట పరిమితులకు వ్యతిరేకంగా మౌలిక సదుపాయాల యొక్క కావలసిన స్థితిని ధృవీకరిస్తుంది.
• నిల్వ బకెట్ యొక్క ఎన్‌క్రిప్షన్ లేకపోవడం లేదా అసురక్షిత, ఇంటర్నెట్ నుండి వర్చువల్ మెషీన్‌లకు ఓపెన్ యాక్సెస్ వంటి సాధారణ లోపాలను గుర్తించడం.
• మౌలిక సదుపాయాల కల్పన అమలును పరిశీలిస్తోంది.
• ప్రొవిజనింగ్ తర్వాత కార్యాచరణను తనిఖీ చేయడానికి మీ “ప్రోగ్రామ్ చేసిన” ఇన్‌ఫ్రాస్ట్రక్చర్‌లో అమలవుతున్న అప్లికేషన్ లాజిక్ యొక్క రన్‌టైమ్ పరీక్షను నిర్వహిస్తోంది.
• మేము చూడగలిగినట్లుగా, విస్తృతమైన మౌలిక సదుపాయాల పరీక్ష ఎంపికలు ఉన్నాయి. ఈ స్పెక్ట్రమ్‌లోని ప్రతి పాయింట్ వద్ద పరీక్షించడానికి పోలుమికి మెకానిజమ్‌లు ఉన్నాయి. ప్రారంభించండి మరియు ఇది ఎలా పని చేస్తుందో చూద్దాం.

యూనిట్ పరీక్ష

పులుమి ప్రోగ్రామ్‌లు జావాస్క్రిప్ట్, పైథాన్, టైప్‌స్క్రిప్ట్ లేదా గో వంటి సాధారణ-ప్రయోజన ప్రోగ్రామింగ్ భాషలలో వ్రాయబడ్డాయి. అందువల్ల, పరీక్ష ఫ్రేమ్‌వర్క్‌లతో సహా ఈ భాషల యొక్క పూర్తి శక్తి వాటి సాధనాలు మరియు లైబ్రరీలతో సహా వారికి అందుబాటులో ఉంటుంది. Pulumi బహుళ-క్లౌడ్, అంటే ఏదైనా క్లౌడ్ ప్రొవైడర్ నుండి పరీక్షించడానికి దీనిని ఉపయోగించవచ్చు.

(ఈ కథనంలో, బహుభాషా మరియు బహుళ క్లౌడ్ అయినప్పటికీ, మేము జావాస్క్రిప్ట్ మరియు మోచాను ఉపయోగిస్తాము మరియు AWSపై దృష్టి కేంద్రీకరిస్తాము. మీరు పైథాన్‌ని ఉపయోగించవచ్చు. unittest, గో టెస్ట్ ఫ్రేమ్‌వర్క్ లేదా మీకు నచ్చిన ఏదైనా ఇతర టెస్ట్ ఫ్రేమ్‌వర్క్. మరియు, వాస్తవానికి, పులుమి అజూర్, గూగుల్ క్లౌడ్, కుబెర్నెట్స్‌తో అద్భుతంగా పనిచేస్తుంది.)

మేము చూసినట్లుగా, మీరు మీ ఇన్‌ఫ్రాస్ట్రక్చర్ కోడ్‌ని పరీక్షించడానికి అనేక కారణాలు ఉన్నాయి. వాటిలో ఒకటి సంప్రదాయ యూనిట్ టెస్టింగ్. ఎందుకంటే మీ కోడ్ ఫంక్షన్‌లను కలిగి ఉండవచ్చు - ఉదాహరణకు, CIDRని లెక్కించడానికి, పేర్లు, ట్యాగ్‌లు మొదలైనవాటిని డైనమిక్‌గా లెక్కించండి. - మీరు బహుశా వాటిని పరీక్షించాలనుకుంటున్నారు. ఇది మీకు ఇష్టమైన ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో అప్లికేషన్‌ల కోసం రెగ్యులర్ యూనిట్ పరీక్షలను రాయడం లాంటిదే.
కొంచెం క్లిష్టంగా ఉండటానికి, మీ ప్రోగ్రామ్ వనరులను ఎలా కేటాయిస్తుందో మీరు తనిఖీ చేయవచ్చు. వివరించడానికి, మనం ఒక సాధారణ EC2 సర్వర్‌ని సృష్టించాల్సిన అవసరం ఉందని ఊహించుకుందాం మరియు మేము ఈ క్రింది వాటిని ఖచ్చితంగా కోరుకుంటున్నాము:

• సందర్భాలకు ట్యాగ్ ఉంటుంది Name.
• సందర్భాలు ఇన్‌లైన్ స్క్రిప్ట్‌ని ఉపయోగించకూడదు userData - మనం తప్పనిసరిగా AMI (చిత్రం)ని ఉపయోగించాలి.
• ఇంటర్నెట్‌కు ఎటువంటి SSH బహిర్గతం కాకూడదు.

ఈ ఉదాహరణ ఆధారంగా ఉంది నా ఉదాహరణ 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();
                }
            });
        });

ఇది సాధారణ పరీక్ష వలె కనిపిస్తుంది, కానీ గమనించదగ్గ కొన్ని లక్షణాలతో:

• విస్తరణకు ముందు మేము వనరు యొక్క స్థితిని ప్రశ్నించడం వలన, మా పరీక్షలు ఎల్లప్పుడూ "ప్లాన్" (లేదా "ప్రివ్యూ") మోడ్‌లో అమలు చేయబడతాయి. అందువల్ల, అనేక లక్షణాలు ఉన్నాయి, వాటి విలువలు కేవలం తిరిగి పొందబడవు లేదా నిర్వచించబడవు. ఇది మీ క్లౌడ్ ప్రొవైడర్ ద్వారా లెక్కించబడిన అన్ని అవుట్‌పుట్ లక్షణాలను కలిగి ఉంటుంది. ఇది మా పరీక్షలకు సాధారణం - మేము ఇన్‌పుట్ డేటాను మాత్రమే తనిఖీ చేస్తాము. ఇంటిగ్రేషన్ పరీక్షల విషయానికి వస్తే మేము ఈ సమస్యకు తిరిగి వస్తాము.
• అన్ని Pulumi వనరుల లక్షణాలు అవుట్‌పుట్‌లు మరియు వాటిలో చాలా వరకు అసమకాలికంగా మూల్యాంకనం చేయబడినందున, మేము విలువలను యాక్సెస్ చేయడానికి దరఖాస్తు పద్ధతిని ఉపయోగించాలి. ఇది వాగ్దానాలు మరియు పనితీరుకు చాలా పోలి ఉంటుంది then .
• లోపం సందేశంలో వనరు URNని చూపడానికి మేము అనేక లక్షణాలను ఉపయోగిస్తున్నందున, మేము ఫంక్షన్‌ను ఉపయోగించాలి pulumi.allవాటిని కలపడానికి.
• చివరగా, ఈ విలువలు అసమకాలికంగా లెక్కించబడినందున, మేము Mocha యొక్క అంతర్నిర్మిత అసమకాలిక కాల్‌బ్యాక్ ఫీచర్‌ని ఉపయోగించాలి 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();
                }
            });
        });

అంతే. ఇప్పుడు పరీక్షలను అమలు చేద్దాం!

పరీక్షలు నడుస్తున్నాయి

చాలా సందర్భాలలో, మీకు నచ్చిన టెస్ట్ ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి మీరు పరీక్షలను సాధారణ పద్ధతిలో అమలు చేయవచ్చు. కానీ పులుమి యొక్క ఒక ప్రత్యేకత ఉంది, అది దృష్టి పెట్టాలి.
సాధారణంగా, Pulumi ప్రోగ్రామ్‌లను అమలు చేయడానికి, పులిమి CLI (కమాండ్ లైన్ ఇంటర్‌ఫేస్) ఉపయోగించబడుతుంది, ఇది భాష రన్‌టైమ్‌ను కాన్ఫిగర్ చేస్తుంది, పులుమి ఇంజిన్ యొక్క ప్రయోగాన్ని నియంత్రిస్తుంది, తద్వారా వనరులతో కార్యకలాపాలు రికార్డ్ చేయబడతాయి మరియు ప్లాన్‌లో చేర్చబడతాయి. అయితే, ఒక సమస్య ఉంది. మీ టెస్ట్ ఫ్రేమ్‌వర్క్ నియంత్రణలో నడుస్తున్నప్పుడు, CLI మరియు Pulumi ఇంజిన్ మధ్య కమ్యూనికేషన్ ఉండదు.

ఈ సమస్యను అధిగమించడానికి, మేము ఈ క్రింది వాటిని పేర్కొనాలి:

• ప్రాజెక్ట్ పేరు, ఇది పర్యావరణ వేరియబుల్‌లో ఉంటుంది 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