ਪੁਲੁਮੀ ਦੇ ਨਾਲ ਕੋਡ ਦੇ ਤੌਰ 'ਤੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਜਾਂਚ ਕਰਨਾ। ਭਾਗ 1

ਸ਼ੁਭ ਦੁਪਹਿਰ ਦੋਸਤੋ। ਦਰ 'ਤੇ ਇੱਕ ਨਵੇਂ ਪ੍ਰਵਾਹ ਦੀ ਸ਼ੁਰੂਆਤ ਦੀ ਉਮੀਦ ਵਿੱਚ "DevOps ਅਭਿਆਸ ਅਤੇ ਸਾਧਨ" ਅਸੀਂ ਤੁਹਾਡੇ ਨਾਲ ਨਵਾਂ ਅਨੁਵਾਦ ਸਾਂਝਾ ਕਰ ਰਹੇ ਹਾਂ। ਜਾਣਾ.

ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਕੋਡ (ਕੋਡ ਵਜੋਂ ਬੁਨਿਆਦੀ ਢਾਂਚਾ) ਲਈ ਪੁਲੁਮੀ ਅਤੇ ਆਮ-ਉਦੇਸ਼ ਦੀਆਂ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਹੁਤ ਸਾਰੇ ਫਾਇਦੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ: ਹੁਨਰ ਅਤੇ ਗਿਆਨ ਦੀ ਉਪਲਬਧਤਾ, ਐਬਸਟਰੈਕਸ਼ਨ ਦੁਆਰਾ ਕੋਡ ਵਿੱਚ ਬਾਇਲਰਪਲੇਟ ਨੂੰ ਖਤਮ ਕਰਨਾ, ਤੁਹਾਡੀ ਟੀਮ ਲਈ ਜਾਣੂ ਟੂਲ, ਜਿਵੇਂ ਕਿ IDEs ਅਤੇ linters। ਇਹ ਸਾਰੇ ਸਾਫਟਵੇਅਰ ਇੰਜਨੀਅਰਿੰਗ ਟੂਲ ਨਾ ਸਿਰਫ਼ ਸਾਨੂੰ ਵਧੇਰੇ ਲਾਭਕਾਰੀ ਬਣਾਉਂਦੇ ਹਨ, ਸਗੋਂ ਸਾਡੇ ਕੋਡ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਵੀ ਸੁਧਾਰ ਕਰਦੇ ਹਨ। ਇਸ ਲਈ, ਇਹ ਸਿਰਫ ਕੁਦਰਤੀ ਹੈ ਕਿ ਆਮ-ਉਦੇਸ਼ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੀ ਵਰਤੋਂ ਸਾਨੂੰ ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਸੌਫਟਵੇਅਰ ਵਿਕਾਸ ਅਭਿਆਸ ਪੇਸ਼ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ - ਟੈਸਟਿੰਗ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਪੁਲੁਮੀ ਸਾਡੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਰੂਪ ਵਿੱਚ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰਨ ਵਿੱਚ ਸਾਡੀ ਕਿਵੇਂ ਮਦਦ ਕਰਦਾ ਹੈ।

ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਜਾਂਚ ਕਿਉਂ?

ਵਿਸਥਾਰ ਵਿੱਚ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਸਵਾਲ ਪੁੱਛਣਾ ਮਹੱਤਵਪੂਰਣ ਹੈ: "ਕਿਉਂ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ?" ਇਸ ਦੇ ਬਹੁਤ ਸਾਰੇ ਕਾਰਨ ਹਨ ਅਤੇ ਇੱਥੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਕੁਝ ਹਨ:

• ਵਿਅਕਤੀਗਤ ਫੰਕਸ਼ਨਾਂ ਜਾਂ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਤਰਕ ਦੇ ਟੁਕੜਿਆਂ ਦੀ ਯੂਨਿਟ ਟੈਸਟਿੰਗ
• ਕੁਝ ਰੁਕਾਵਟਾਂ ਦੇ ਵਿਰੁੱਧ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਲੋੜੀਂਦੀ ਸਥਿਤੀ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ।
• ਆਮ ਤਰੁਟੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ, ਜਿਵੇਂ ਕਿ ਸਟੋਰੇਜ ਬਾਲਟੀ ਦੀ ਏਨਕ੍ਰਿਪਸ਼ਨ ਦੀ ਘਾਟ ਜਾਂ ਅਸੁਰੱਖਿਅਤ, ਇੰਟਰਨੈਟ ਤੋਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਤੱਕ ਖੁੱਲ੍ਹੀ ਪਹੁੰਚ।
• ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਪ੍ਰਬੰਧ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ।
• ਪ੍ਰੋਵਿਜ਼ਨਿੰਗ ਤੋਂ ਬਾਅਦ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਤੁਹਾਡੇ "ਪ੍ਰੋਗਰਾਮ ਕੀਤੇ" ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਚੱਲ ਰਹੇ ਐਪਲੀਕੇਸ਼ਨ ਤਰਕ ਦੀ ਰਨਟਾਈਮ ਟੈਸਟਿੰਗ ਕਰਨਾ।
• ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਟੈਸਟਿੰਗ ਵਿਕਲਪਾਂ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਹੈ. ਪੋਲੂਮੀ ਕੋਲ ਇਸ ਸਪੈਕਟ੍ਰਮ ਦੇ ਹਰ ਬਿੰਦੂ 'ਤੇ ਟੈਸਟ ਕਰਨ ਲਈ ਵਿਧੀ ਹੈ। ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

ਯੂਨਿਟ ਟੈਸਟਿੰਗ

ਪੁਲੁਮੀ ਪ੍ਰੋਗਰਾਮ ਆਮ-ਉਦੇਸ਼ ਵਾਲੀਆਂ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਜਿਵੇਂ ਕਿ JavaScript, Python, TypeScript ਜਾਂ Go ਵਿੱਚ ਲਿਖੇ ਜਾਂਦੇ ਹਨ। ਇਸ ਲਈ, ਇਹਨਾਂ ਭਾਸ਼ਾਵਾਂ ਦੀ ਪੂਰੀ ਸ਼ਕਤੀ, ਉਹਨਾਂ ਦੇ ਸੰਦਾਂ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਸਮੇਤ, ਟੈਸਟ ਫਰੇਮਵਰਕ ਸਮੇਤ, ਉਹਨਾਂ ਲਈ ਉਪਲਬਧ ਹੈ। ਪੁਲੁਮੀ ਮਲਟੀ-ਕਲਾਊਡ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਸਦੀ ਵਰਤੋਂ ਕਿਸੇ ਵੀ ਕਲਾਉਡ ਪ੍ਰਦਾਤਾ ਤੋਂ ਜਾਂਚ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

(ਇਸ ਲੇਖ ਵਿੱਚ, ਬਹੁਭਾਸ਼ਾਈ ਅਤੇ ਮਲਟੀਕਲਾਉਡ ਹੋਣ ਦੇ ਬਾਵਜੂਦ, ਅਸੀਂ 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 ਜਾਂ ਇੱਕ ਵਾਅਦਾ ਵਾਪਸ ਕਰਨਾ।

ਇੱਕ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਸਭ ਕੁਝ ਸੈੱਟ ਕਰ ਲੈਂਦੇ ਹਾਂ, ਤਾਂ ਸਾਡੇ ਕੋਲ ਸਧਾਰਨ 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();
                }
            });
        });

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਆਓ ਤੀਜਾ ਟੈਸਟ ਲਿਖੀਏ। ਇਹ ਥੋੜਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਹੋਵੇਗਾ ਕਿਉਂਕਿ ਅਸੀਂ ਸੁਰੱਖਿਆ ਸਮੂਹ ਨਾਲ ਜੁੜੇ ਲੌਗਇਨ ਨਿਯਮਾਂ ਦੀ ਖੋਜ ਕਰ ਰਹੇ ਹਾਂ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਨਿਯਮਾਂ ਵਿੱਚ ਸੀਆਈਡੀਆਰ ਰੇਂਜ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਹੋ ਸਕਦੇ ਹਨ। ਪਰ ਅਸੀਂ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ:

    // 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 (ਕਮਾਂਡ ਲਾਈਨ ਇੰਟਰਫੇਸ) ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਭਾਸ਼ਾ ਦੇ ਰਨਟਾਈਮ ਨੂੰ ਸੰਰਚਿਤ ਕਰਦਾ ਹੈ, ਪੁਲੁਮੀ ਇੰਜਣ ਦੇ ਲਾਂਚ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਸਰੋਤਾਂ ਦੇ ਨਾਲ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਰਿਕਾਰਡ ਕੀਤਾ ਜਾ ਸਕੇ ਅਤੇ ਯੋਜਨਾ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾ ਸਕੇ, ਆਦਿ। ਹਾਲਾਂਕਿ, ਇੱਕ ਸਮੱਸਿਆ ਹੈ. ਜਦੋਂ ਤੁਹਾਡੇ ਟੈਸਟ ਫਰੇਮਵਰਕ ਦੇ ਨਿਯੰਤਰਣ ਵਿੱਚ ਚੱਲ ਰਿਹਾ ਹੋਵੇ, ਤਾਂ 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