ಪುಲುಮಿಯೊಂದಿಗೆ ಕೋಡ್‌ನಂತೆ ಮೂಲಸೌಕರ್ಯವನ್ನು ಪರೀಕ್ಷಿಸಿ. ಭಾಗ 1

ಶುಭ ಮಧ್ಯಾಹ್ನ ಸ್ನೇಹಿತರೇ. ದರದಲ್ಲಿ ಹೊಸ ಹರಿವಿನ ಪ್ರಾರಂಭದ ನಿರೀಕ್ಷೆಯಲ್ಲಿ "DevOps ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಪರಿಕರಗಳು" ನಾವು ನಿಮ್ಮೊಂದಿಗೆ ಹೊಸ ಅನುವಾದವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತಿದ್ದೇವೆ. ಹೋಗು.

ಮೂಲಸೌಕರ್ಯ ಕೋಡ್‌ಗಾಗಿ ಪುಲುಮಿ ಮತ್ತು ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಬಳಸುವುದು (ಕೋಡ್‌ನಂತೆ ಮೂಲಸೌಕರ್ಯ) ಅನೇಕ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ಕೌಶಲ್ಯ ಮತ್ತು ಜ್ಞಾನದ ಲಭ್ಯತೆ, ಅಮೂರ್ತತೆಯ ಮೂಲಕ ಕೋಡ್‌ನಲ್ಲಿ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಅನ್ನು ತೆಗೆದುಹಾಕುವುದು, ನಿಮ್ಮ ತಂಡಕ್ಕೆ ಪರಿಚಿತವಾಗಿರುವ ಸಾಧನಗಳಾದ IDE ಗಳು ಮತ್ತು ಲಿಂಟರ್‌ಗಳು. ಈ ಎಲ್ಲಾ ಸಾಫ್ಟ್‌ವೇರ್ ಇಂಜಿನಿಯರಿಂಗ್ ಉಪಕರಣಗಳು ನಮ್ಮನ್ನು ಹೆಚ್ಚು ಉತ್ಪಾದಕವಾಗಿಸುತ್ತದೆ, ಆದರೆ ನಮ್ಮ ಕೋಡ್‌ನ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳ ಬಳಕೆಯು ನಮಗೆ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಅಭ್ಯಾಸವನ್ನು ಪರಿಚಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ - ಪರೀಕ್ಷೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ನಮ್ಮ ಮೂಲಸೌಕರ್ಯವನ್ನು ಕೋಡ್‌ನಂತೆ ಪರೀಕ್ಷಿಸಲು ಪುಲುಮಿ ನಮಗೆ ಹೇಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.

ಮೂಲಸೌಕರ್ಯವನ್ನು ಏಕೆ ಪರೀಕ್ಷಿಸಬೇಕು?

ವಿವರಗಳಿಗೆ ಹೋಗುವ ಮೊದಲು, “ಮೂಲಸೌಕರ್ಯವನ್ನು ಏಕೆ ಪರೀಕ್ಷಿಸಬೇಕು?” ಎಂಬ ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ. ಇದಕ್ಕೆ ಹಲವು ಕಾರಣಗಳಿವೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಇಲ್ಲಿವೆ:

• ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ತರ್ಕದ ಪ್ರತ್ಯೇಕ ಕಾರ್ಯಗಳು ಅಥವಾ ತುಣುಕುಗಳ ಘಟಕ ಪರೀಕ್ಷೆ
• ಕೆಲವು ನಿರ್ಬಂಧಗಳ ವಿರುದ್ಧ ಮೂಲಸೌಕರ್ಯದ ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.
• ಶೇಖರಣಾ ಬಕೆಟ್‌ನ ಗೂಢಲಿಪೀಕರಣದ ಕೊರತೆ ಅಥವಾ ಅಸುರಕ್ಷಿತ, ವರ್ಚುವಲ್ ಯಂತ್ರಗಳಿಗೆ ಇಂಟರ್ನೆಟ್‌ನಿಂದ ಮುಕ್ತ ಪ್ರವೇಶದಂತಹ ಸಾಮಾನ್ಯ ದೋಷಗಳ ಪತ್ತೆ.
• ಮೂಲಸೌಕರ್ಯ ಒದಗಿಸುವಿಕೆಯ ಅನುಷ್ಠಾನವನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ.
• ಒದಗಿಸಿದ ನಂತರ ಕಾರ್ಯವನ್ನು ಪರಿಶೀಲಿಸಲು ನಿಮ್ಮ "ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲಾದ" ಮೂಲಸೌಕರ್ಯದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್ ಲಾಜಿಕ್‌ನ ರನ್‌ಟೈಮ್ ಪರೀಕ್ಷೆಯನ್ನು ನಿರ್ವಹಿಸುವುದು.
• ನಾವು ನೋಡುವಂತೆ, ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಮೂಲಸೌಕರ್ಯ ಪರೀಕ್ಷೆಯ ಆಯ್ಕೆಗಳಿವೆ. ಪೊಲುಮಿ ಈ ಸ್ಪೆಕ್ಟ್ರಮ್‌ನಲ್ಲಿ ಪ್ರತಿ ಹಂತದಲ್ಲಿಯೂ ಪರೀಕ್ಷೆಗೆ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ. ಪ್ರಾರಂಭಿಸೋಣ ಮತ್ತು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

ಘಟಕ ಪರೀಕ್ಷೆ

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

(ಈ ಲೇಖನದಲ್ಲಿ, ಬಹುಭಾಷಾ ಮತ್ತು ಬಹುಕ್ಲೌಡ್ ಆಗಿದ್ದರೂ, ನಾವು JavaScript ಮತ್ತು Mocha ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು 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();
                }
            });
        });

ಇದು ಸಾಮಾನ್ಯ ಪರೀಕ್ಷೆಯಂತೆ ಕಾಣುತ್ತದೆ, ಆದರೆ ಗಮನಿಸಬೇಕಾದ ಕೆಲವು ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ:

• ನಿಯೋಜನೆಯ ಮೊದಲು ನಾವು ಸಂಪನ್ಮೂಲದ ಸ್ಥಿತಿಯನ್ನು ಪ್ರಶ್ನಿಸುವುದರಿಂದ, ನಮ್ಮ ಪರೀಕ್ಷೆಗಳು ಯಾವಾಗಲೂ "ಯೋಜನೆ" (ಅಥವಾ "ಪೂರ್ವವೀಕ್ಷಣೆ") ಮೋಡ್‌ನಲ್ಲಿ ರನ್ ಆಗುತ್ತವೆ. ಹೀಗಾಗಿ, ಅನೇಕ ಗುಣಲಕ್ಷಣಗಳಿವೆ, ಅದರ ಮೌಲ್ಯಗಳನ್ನು ಸರಳವಾಗಿ ಹಿಂಪಡೆಯಲಾಗುವುದಿಲ್ಲ ಅಥವಾ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುವುದಿಲ್ಲ. ಇದು ನಿಮ್ಮ ಕ್ಲೌಡ್ ಪೂರೈಕೆದಾರರಿಂದ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲಾದ ಎಲ್ಲಾ ಔಟ್‌ಪುಟ್ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಇದು ನಮ್ಮ ಪರೀಕ್ಷೆಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿದೆ - ನಾವು ಇನ್‌ಪುಟ್ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ಏಕೀಕರಣ ಪರೀಕ್ಷೆಗಳಿಗೆ ಬಂದಾಗ ನಾವು ನಂತರ ಈ ಸಮಸ್ಯೆಗೆ ಹಿಂತಿರುಗುತ್ತೇವೆ.
• ಎಲ್ಲಾ ಪುಲುಮಿ ಸಂಪನ್ಮೂಲ ಗುಣಲಕ್ಷಣಗಳು ಔಟ್‌ಪುಟ್‌ಗಳಾಗಿರುವುದರಿಂದ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವು ಅಸಮಕಾಲಿಕವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲ್ಪಟ್ಟಿರುವುದರಿಂದ, ಮೌಲ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ನಾವು ಅನ್ವಯಿಸುವ ವಿಧಾನವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಇದು ಭರವಸೆಗಳು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಹೋಲುತ್ತದೆ then .
• ದೋಷ ಸಂದೇಶದಲ್ಲಿ ಸಂಪನ್ಮೂಲ URN ಅನ್ನು ತೋರಿಸಲು ನಾವು ಹಲವಾರು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸುತ್ತಿರುವುದರಿಂದ, ನಾವು ಕಾರ್ಯವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ pulumi.allಅವುಗಳನ್ನು ಸಂಯೋಜಿಸಲು.
• ಅಂತಿಮವಾಗಿ, ಈ ಮೌಲ್ಯಗಳನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲಾಗಿರುವುದರಿಂದ, ನಾವು ಮೋಚಾದ ಅಂತರ್ನಿರ್ಮಿತ ಅಸಿಂಕ್ ಕಾಲ್‌ಬ್ಯಾಕ್ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ done ಅಥವಾ ಭರವಸೆಯನ್ನು ಹಿಂದಿರುಗಿಸುವುದು.

ಒಮ್ಮೆ ನಾವು ಎಲ್ಲವನ್ನೂ ಹೊಂದಿಸಿದಲ್ಲಿ, ನಾವು ಸರಳವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೌಲ್ಯಗಳಾಗಿ ಇನ್‌ಪುಟ್‌ಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತೇವೆ. ಆಸ್ತಿ 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 ಎಂಜಿನ್ ನಡುವೆ ಯಾವುದೇ ಸಂವಹನವಿರುವುದಿಲ್ಲ.

ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿದೆ:

• ಪರಿಸರ ವೇರಿಯಬಲ್‌ನಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಯೋಜನೆಯ ಹೆಸರು 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