પુલુમી સાથે કોડ તરીકે ઈન્ફ્રાસ્ટ્રક્ચરનું પરીક્ષણ. ભાગ 1

શુભ બપોર મિત્રો. દરે નવા પ્રવાહની શરૂઆતની અપેક્ષાએ "DevOps પ્રેક્ટિસ અને ટૂલ્સ" અમે તમારી સાથે એક નવો અનુવાદ શેર કરી રહ્યા છીએ. જાઓ.

ઈન્ફ્રાસ્ટ્રક્ચર કોડ (કોડ તરીકે ઈન્ફ્રાસ્ટ્રક્ચર) માટે પુલુમી અને સામાન્ય હેતુવાળી પ્રોગ્રામિંગ ભાષાઓનો ઉપયોગ ઘણા ફાયદાઓ પૂરા પાડે છે: કુશળતા અને જ્ઞાનની ઉપલબ્ધતા, એબ્સ્ટ્રેક્શન દ્વારા કોડમાં બોઈલરપ્લેટને દૂર કરવા, તમારી ટીમને પરિચિત સાધનો, જેમ કે IDEs અને linters. આ તમામ સૉફ્ટવેર એન્જિનિયરિંગ સાધનો માત્ર અમને વધુ ઉત્પાદક બનાવે છે, પરંતુ અમારા કોડની ગુણવત્તામાં પણ સુધારો કરે છે. તેથી, તે સ્વાભાવિક છે કે સામાન્ય હેતુવાળી પ્રોગ્રામિંગ ભાષાઓનો ઉપયોગ અમને અન્ય મહત્વપૂર્ણ સોફ્ટવેર ડેવલપમેન્ટ પ્રેક્ટિસ રજૂ કરવાની મંજૂરી આપે છે - પરીક્ષણ.

આ લેખમાં, અમે જોઈશું કે પુલુમી અમારા ઈન્ફ્રાસ્ટ્રક્ચર-એઝ-કોડને ચકાસવામાં કેવી રીતે મદદ કરે છે.

ઇન્ફ્રાસ્ટ્રક્ચરનું પરીક્ષણ શા માટે?

વિગતવાર જતાં પહેલાં, તે પ્રશ્ન પૂછવા યોગ્ય છે: "શા માટે ઇન્ફ્રાસ્ટ્રક્ચરનું પરીક્ષણ બિલકુલ?" આના માટે ઘણા કારણો છે અને તેમાંથી કેટલાક અહીં છે:

• વ્યક્તિગત કાર્યો અથવા તમારા પ્રોગ્રામ લોજિકના ટુકડાઓનું એકમ પરીક્ષણ
• ચોક્કસ અવરોધો સામે ઇન્ફ્રાસ્ટ્રક્ચરની ઇચ્છિત સ્થિતિને ચકાસે છે.
• સામાન્ય ભૂલોની શોધ, જેમ કે સ્ટોરેજ બકેટના એન્ક્રિપ્શનનો અભાવ અથવા અસુરક્ષિત, ઇન્ટરનેટથી વર્ચ્યુઅલ મશીનો સુધીની ખુલ્લી ઍક્સેસ.
• ઈન્ફ્રાસ્ટ્રક્ચર જોગવાઈના અમલીકરણની તપાસ કરી રહ્યા છીએ.
• જોગવાઈ કર્યા પછી કાર્યક્ષમતા ચકાસવા માટે તમારા "પ્રોગ્રામ કરેલ" ઈન્ફ્રાસ્ટ્રક્ચરની અંદર ચાલતા એપ્લિકેશન તર્કનું રનટાઇમ પરીક્ષણ કરવું.
• જેમ આપણે જોઈ શકીએ છીએ, ત્યાં ઈન્ફ્રાસ્ટ્રક્ચર પરીક્ષણ વિકલ્પોની વિશાળ શ્રેણી છે. પોલુમી પાસે આ સ્પેક્ટ્રમ પરના દરેક બિંદુઓ પર પરીક્ષણ માટે મિકેનિઝમ્સ છે. ચાલો પ્રારંભ કરીએ અને જોઈએ કે તે કેવી રીતે કાર્ય કરે છે.

એકમ પરીક્ષણ

પુલુમી પ્રોગ્રામ્સ જાવાસ્ક્રિપ્ટ, પાયથોન, ટાઈપસ્ક્રીપ્ટ અથવા ગો જેવી સામાન્ય હેતુવાળી પ્રોગ્રામિંગ ભાષાઓમાં લખવામાં આવે છે. તેથી, આ ભાષાઓની સંપૂર્ણ શક્તિ, તેમના સાધનો અને પુસ્તકાલયો સહિત, પરીક્ષણ ફ્રેમવર્ક સહિત, તેમને ઉપલબ્ધ છે. પુલુમી મલ્ટિ-ક્લાઉડ છે, જેનો અર્થ છે કે તેનો ઉપયોગ કોઈપણ ક્લાઉડ પ્રદાતા પાસેથી પરીક્ષણ માટે થઈ શકે છે.

(આ લેખમાં, બહુભાષી અને મલ્ટીક્લાઉડ હોવા છતાં, અમે JavaScript અને Mocha નો ઉપયોગ કરીએ છીએ અને AWS પર ધ્યાન કેન્દ્રિત કરીએ છીએ. તમે Python નો ઉપયોગ કરી શકો છો. 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();
                }
            });
        });

અને છેલ્લે, ચાલો ત્રીજી કસોટી લખીએ. આ થોડું વધુ જટિલ હશે કારણ કે અમે સુરક્ષા જૂથ સાથે સંકળાયેલા લોગિન નિયમો શોધી રહ્યા છીએ, જેમાંથી ઘણા હોઈ શકે છે, અને તે નિયમોમાં 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