🥇ಪುಲುಮಿಯನ್ನು ಬಳಸುವ ಕೋಡ್‌ನಂತೆ ಮೂಲಸೌಕರ್ಯ ಪರೀಕ್ಷೆ. ಭಾಗ 2

ಎಲ್ಲರಿಗು ನಮಸ್ಖರ. ಇಂದು ನಾವು ಲೇಖನದ ಅಂತಿಮ ಭಾಗವನ್ನು ನಿಮ್ಮೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳುತ್ತೇವೆ. "ಪುಲುಮಿಯೊಂದಿಗೆ ಮೂಲಸೌಕರ್ಯವನ್ನು ಕೋಡ್‌ನಂತೆ ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ", ಇದರ ಅನುವಾದವನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ಕೋರ್ಸ್ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಸಿದ್ಧಪಡಿಸಲಾಗಿದೆ "DevOps ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಪರಿಕರಗಳು".

ನಿಯೋಜನೆ ಪರೀಕ್ಷೆ

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

Pulumi ಏಕೀಕರಣ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟನ್ನು Go ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ, ನಮ್ಮ ಆಂತರಿಕ ಕೋಡ್ ಅನ್ನು ನಾವು ಹೇಗೆ ಪರೀಕ್ಷಿಸುತ್ತೇವೆ. ಹಿಂದೆ ಚರ್ಚಿಸಲಾದ ಘಟಕ ಪರೀಕ್ಷೆಯ ವಿಧಾನವು ಬಿಳಿ ಪೆಟ್ಟಿಗೆಯ ಪರೀಕ್ಷೆಯಂತೆಯೇ ಇದ್ದರೆ, ಏಕೀಕರಣ ಪರೀಕ್ಷೆಯು ಕಪ್ಪು ಪೆಟ್ಟಿಗೆಯಾಗಿದೆ. (ಕಠಿಣ ಆಂತರಿಕ ಪರೀಕ್ಷೆಗೆ ಆಯ್ಕೆಗಳೂ ಇವೆ.) ಈ ಚೌಕಟ್ಟನ್ನು ಸಂಪೂರ್ಣ ಪುಲುಮಿ ಕಾರ್ಯಕ್ರಮವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಮತ್ತು ಅದರ ಮೇಲೆ ವಿವಿಧ ಜೀವನಚಕ್ರ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಲು ರಚಿಸಲಾಗಿದೆ, ಉದಾಹರಣೆಗೆ ಮೊದಲಿನಿಂದ ಹೊಸ ಸ್ಟಾಕ್ ಅನ್ನು ನಿಯೋಜಿಸುವುದು, ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ಅದನ್ನು ನವೀಕರಿಸುವುದು ಮತ್ತು ಅದನ್ನು ಅಳಿಸುವುದು, ಬಹುಶಃ ಹಲವಾರು ಬಾರಿ . ನಾವು ಅವುಗಳನ್ನು ನಿಯಮಿತವಾಗಿ ನಡೆಸುತ್ತೇವೆ (ಉದಾಹರಣೆಗೆ, ರಾತ್ರಿಯಲ್ಲಿ) ಮತ್ತು ಒತ್ತಡ ಪರೀಕ್ಷೆಗಳಂತೆ.

(ನಾವು ನಾವು ಅದರ ಮೇಲೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ಒಂದೇ ರೀತಿಯ ಏಕೀಕರಣ ಪರೀಕ್ಷೆಯ ಸಾಮರ್ಥ್ಯಗಳು ಸ್ಥಳೀಯ ಭಾಷೆಗಳ SDK ನಲ್ಲಿ ಲಭ್ಯವಿದೆ. ನಿಮ್ಮ ಪುಲುಮಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಯಾವ ಭಾಷೆಯಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ ನೀವು ಗೋ ಏಕೀಕರಣ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟನ್ನು ಬಳಸಬಹುದು).

ಈ ಚೌಕಟ್ಟನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪರಿಶೀಲಿಸಬಹುದು:

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

ನಾವು ಶೀಘ್ರದಲ್ಲೇ ನೋಡುವಂತೆ, ರನ್ಟೈಮ್ ಮೌಲ್ಯೀಕರಣವನ್ನು ನಿರ್ವಹಿಸಲು ಈ ಚೌಕಟ್ಟನ್ನು ಸಹ ಬಳಸಬಹುದು.

ಸರಳ ಏಕೀಕರಣ ಪರೀಕ್ಷೆ

ಇದನ್ನು ಕ್ರಿಯೆಯಲ್ಲಿ ನೋಡಲು, ನಾವು ರೆಪೊಸಿಟರಿಯನ್ನು ನೋಡುತ್ತೇವೆ pulumi/examples, ನಮ್ಮ ತಂಡ ಮತ್ತು ಪುಲುಮಿ ಸಮುದಾಯವು ನಮ್ಮದೇ ಆದ ಪುಲ್ ವಿನಂತಿಗಳು, ಬದ್ಧತೆಗಳು ಮತ್ತು ರಾತ್ರಿಯ ನಿರ್ಮಾಣಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಇದನ್ನು ಬಳಸುತ್ತದೆ.

ನಮ್ಮ ಒಂದು ಸರಳೀಕೃತ ಪರೀಕ್ಷೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ S3 ಬಕೆಟ್ ಮತ್ತು ಇತರ ಕೆಲವು ವಸ್ತುಗಳನ್ನು ಒದಗಿಸುವ ಉದಾಹರಣೆ:

example_test.go:

package test
 
import (
    "os"
    "path"
    "testing"
 
    "github.com/pulumi/pulumi/pkg/testing/integration"
)
 
func TestExamples(t *testing.T) {
    awsRegion := os.Getenv("AWS_REGION")
    if awsRegion == "" {
        awsRegion = "us-west-1"
    }
    cwd, _ := os.Getwd()
    integration.ProgramTest(t, &integration.ProgramTestOptions{
        Quick:       true,
        SkipRefresh: true,
        Dir:         path.Join(cwd, "..", "..", "aws-js-s3-folder"),
        Config: map[string]string{
            "aws:region": awsRegion,
        },
    })
}

ಈ ಪರೀಕ್ಷೆಯು ಫೋಲ್ಡರ್‌ಗಾಗಿ ಸ್ಟಾಕ್ ಅನ್ನು ರಚಿಸುವ, ಮಾರ್ಪಡಿಸುವ ಮತ್ತು ನಾಶಮಾಡುವ ಮೂಲಭೂತ ಜೀವನಚಕ್ರದ ಮೂಲಕ ಹೋಗುತ್ತದೆ aws-js-s3-folder. ಉತ್ತೀರ್ಣವಾದ ಪರೀಕ್ಷೆಯನ್ನು ವರದಿ ಮಾಡಲು ಇದು ಸುಮಾರು ಒಂದು ನಿಮಿಷ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ:

$ go test .
PASS
ok      ... 43.993s

ಈ ಪರೀಕ್ಷೆಗಳ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ಹಲವು ಆಯ್ಕೆಗಳಿವೆ. ಆಯ್ಕೆಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ನೋಡಿ. ರಚನೆಯಲ್ಲಿ ProgramTestOptions. ಉದಾಹರಣೆಗೆ, ನೀವು ಜೇಗರ್ ಎಂಡ್ ಪಾಯಿಂಟ್ ಅನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು (Tracing), ಪರೀಕ್ಷೆಯು ನಕಾರಾತ್ಮಕವಾಗಿದ್ದರೆ ಪರೀಕ್ಷೆಯು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಎಂದು ನೀವು ನಿರೀಕ್ಷಿಸುತ್ತೀರಿ ಎಂದು ಸೂಚಿಸಿ (ExpectFailure), ರಾಜ್ಯಗಳ ಅನುಕ್ರಮ ಪರಿವರ್ತನೆಗಾಗಿ ಪ್ರೋಗ್ರಾಂಗೆ "ಸಂಪಾದನೆಗಳ" ಸರಣಿಯನ್ನು ಅನ್ವಯಿಸಿ (EditDirs) ಮತ್ತು ಹೆಚ್ಚು. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ನಿಯೋಜನೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ಅವುಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ನೋಡೋಣ.

ಸಂಪನ್ಮೂಲ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

ಮೇಲೆ ಚರ್ಚಿಸಿದ ಏಕೀಕರಣವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ "ಕೆಲಸ ಮಾಡುತ್ತದೆ" ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ - ಅದು ಕ್ರ್ಯಾಶ್ ಆಗುವುದಿಲ್ಲ. ಆದರೆ ಫಲಿತಾಂಶದ ಸ್ಟಾಕ್ನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನಾವು ಪರಿಶೀಲಿಸಲು ಬಯಸಿದರೆ ಏನು? ಉದಾಹರಣೆಗೆ, ಕೆಲವು ರೀತಿಯ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆ (ಅಥವಾ ಇಲ್ಲ) ಮತ್ತು ಅವು ಕೆಲವು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿವೆ.

ನಿಯತಾಂಕ ExtraRuntimeValidation ಗೆ ProgramTestOptions ಪುಲುಮಿ ದಾಖಲಿಸಿದ ನಂತರದ ನಿಯೋಜನೆ ಸ್ಥಿತಿಯನ್ನು ನೋಡಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ಆದ್ದರಿಂದ ನಾವು ಹೆಚ್ಚುವರಿ ಪರಿಶೀಲನೆಗಳನ್ನು ಮಾಡಬಹುದು. ಇದು ಸಂರಚನೆ, ರಫ್ತು ಮಾಡಿದ ಔಟ್‌ಪುಟ್ ಮೌಲ್ಯಗಳು, ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಅವುಗಳ ಆಸ್ತಿ ಮೌಲ್ಯಗಳು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳ ನಡುವಿನ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಫಲಿತಾಂಶದ ಸ್ಟಾಕ್‌ನ ಸ್ಥಿತಿಯ ಸಂಪೂರ್ಣ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ.

ಇದರ ಮೂಲ ಉದಾಹರಣೆಯನ್ನು ನೋಡಲು, ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದನ್ನು ರಚಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸೋಣ S3 ಬಕೆಟ್:

  integration.ProgramTest(t, &integration.ProgramTestOptions{
        // as before...
        ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
            var foundBuckets int
            for _, res := range stack.Deployment.Resources {
                if res.Type == "aws:s3/bucket:Bucket" {
                    foundBuckets++
                }
            }
            assert.Equal(t, 1, foundBuckets, "Expected to find a single AWS S3 Bucket")
        },
    })

ಈಗ, ನಾವು ಗೋ ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸಿದಾಗ, ಅದು ಬ್ಯಾಟರಿಯ ಜೀವನಚಕ್ರ ಪರೀಕ್ಷೆಗಳ ಮೂಲಕ ಹೋಗುವುದಲ್ಲದೆ, ಸ್ಟಾಕ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ನಿಯೋಜಿಸಿದ ನಂತರ, ಫಲಿತಾಂಶದ ಸ್ಥಿತಿಯ ಮೇಲೆ ಹೆಚ್ಚುವರಿ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡುತ್ತದೆ.

ರನ್ಟೈಮ್ ಪರೀಕ್ಷೆಗಳು

ಇಲ್ಲಿಯವರೆಗೆ, ಎಲ್ಲಾ ಪರೀಕ್ಷೆಗಳು ಸಂಪೂರ್ಣವಾಗಿ ನಿಯೋಜನೆ ನಡವಳಿಕೆ ಮತ್ತು ಪುಲುಮಿ ಸಂಪನ್ಮೂಲ ಮಾದರಿಯ ಬಗ್ಗೆ. ನಿಮ್ಮ ಒದಗಿಸಿದ ಮೂಲಸೌಕರ್ಯವು ನಿಜವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸಿದರೆ ಏನು ಮಾಡಬೇಕು? ಉದಾಹರಣೆಗೆ, ವರ್ಚುವಲ್ ಯಂತ್ರವು ಚಾಲನೆಯಲ್ಲಿದೆ, S3 ಬಕೆಟ್ ನಾವು ಏನನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತೇವೆ, ಇತ್ಯಾದಿಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

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

ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಪರೀಕ್ಷಾ ಪ್ರೋಗ್ರಾಂ ಆಸ್ತಿಯನ್ನು ರಫ್ತು ಮಾಡುತ್ತದೆ webEndpoint ಎಂಬ ಬಕೆಟ್ websiteUrl, ಇದು ಪೂರ್ಣ URL ಆಗಿದ್ದು ಅಲ್ಲಿ ನಾವು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾಗಿದೆ index document. ನಾವು ಹುಡುಕಲು ರಾಜ್ಯದ ಕಡತವನ್ನು ಅಗೆಯಬಹುದು ಆದರೂ bucket ಮತ್ತು ಆ ಆಸ್ತಿಯನ್ನು ನೇರವಾಗಿ ಓದಿ, ಆದರೆ ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಮ್ಮ ಸ್ಟ್ಯಾಕ್‌ಗಳು ಈ ರೀತಿಯ ಉಪಯುಕ್ತ ಗುಣಲಕ್ಷಣಗಳನ್ನು ರಫ್ತು ಮಾಡುತ್ತವೆ, ಅದನ್ನು ಪರಿಶೀಲಿಸಲು ನಾವು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ:

integration.ProgramTest(t, &integration.ProgramTestOptions{
            // as before ...
        ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
            url := "http://" + stack.Outputs["websiteUrl"].(string)
            resp, err := http.Get(url)
            if !assert.NoError(t, err) {
                return
            }
            if !assert.Equal(t, 200, resp.StatusCode) {
                return
            }
            defer resp.Body.Close()
            body, err := ioutil.ReadAll(resp.Body)
            if !assert.NoError(t, err) {
                return
            }
            assert.Contains(t, string(body), "Hello, Pulumi!")
        },
    })

ನಮ್ಮ ಹಿಂದಿನ ರನ್‌ಟೈಮ್ ಚೆಕ್‌ಗಳಂತೆ, ಸ್ಟಾಕ್ ಅನ್ನು ಹೆಚ್ಚಿಸಿದ ತಕ್ಷಣ ಈ ಚೆಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಎಲ್ಲವೂ ಸರಳ ಕರೆಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ go test. ಮತ್ತು ಅದು ಮಂಜುಗಡ್ಡೆಯ ತುದಿ ಮಾತ್ರ-ನೀವು ಕೋಡ್‌ನಲ್ಲಿ ಬರೆಯಬಹುದಾದ ಪ್ರತಿಯೊಂದು Go ಪರೀಕ್ಷಾ ವೈಶಿಷ್ಟ್ಯವು ಲಭ್ಯವಿದೆ.

ನಿರಂತರ ಮೂಲಸೌಕರ್ಯ ಏಕೀಕರಣ

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

ವಿಲೀನಗೊಳಿಸುವ ಮೊದಲು ಪರೀಕ್ಷೆಗಾಗಿ ಪ್ರತಿ ತೆರೆದ ಪುಲ್ ವಿನಂತಿಯಲ್ಲಿ.
ಪ್ರತಿ ಬದ್ಧತೆಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ, ವಿಲೀನವನ್ನು ಸರಿಯಾಗಿ ಮಾಡಲಾಗಿದೆಯೇ ಎಂದು ಎರಡು ಬಾರಿ ಪರಿಶೀಲಿಸಿ.
ನಿಯತಕಾಲಿಕವಾಗಿ, ಹೆಚ್ಚುವರಿ ಪರೀಕ್ಷೆಗಾಗಿ ರಾತ್ರಿ ಅಥವಾ ವಾರಕ್ಕೊಮ್ಮೆ.
ಕಾರ್ಯಕ್ಷಮತೆ ಅಥವಾ ಒತ್ತಡದ ಪರೀಕ್ಷೆಯ ಭಾಗವಾಗಿ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ದೀರ್ಘಾವಧಿಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಸಮಾನಾಂತರವಾಗಿ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತದೆ ಮತ್ತು/ಅಥವಾ ಅದೇ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹಲವು ಬಾರಿ ನಿಯೋಜಿಸುತ್ತದೆ.

ಇವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದಕ್ಕೂ, ಪುಲುಮಿ ನಿಮ್ಮ ನೆಚ್ಚಿನ ನಿರಂತರ ಏಕೀಕರಣ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಏಕೀಕರಣವನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ನಿರಂತರ ಏಕೀಕರಣದೊಂದಿಗೆ, ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸಾಫ್ಟ್‌ವೇರ್‌ಗಾಗಿ ನಿಮ್ಮ ಮೂಲಸೌಕರ್ಯಕ್ಕಾಗಿ ಅದೇ ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಯನ್ನು ನೀಡುತ್ತದೆ.

ಸಾಮಾನ್ಯ CI ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಪುಲುಮಿ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ. ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಇಲ್ಲಿವೆ:

ಹೆಚ್ಚಿನ ವಿವರವಾದ ಮಾಹಿತಿಗಾಗಿ, ದಯವಿಟ್ಟು ದಸ್ತಾವೇಜನ್ನು ನೋಡಿ ನಿರಂತರ ವಿತರಣೆ.

ಅಲ್ಪಕಾಲಿಕ ಪರಿಸರಗಳು

ಕೇವಲ ಸ್ವೀಕಾರ ಪರೀಕ್ಷೆಯ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅಲ್ಪಕಾಲಿಕ ಪರಿಸರವನ್ನು ನಿಯೋಜಿಸುವ ಸಾಮರ್ಥ್ಯವು ತೆರೆಯುವ ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ಅವಕಾಶವಾಗಿದೆ. ಪರಿಕಲ್ಪನೆ ಯೋಜನೆಗಳು ಮತ್ತು ರಾಶಿಗಳು ಕೆಲವು ಸರಳ CLI ಆಜ್ಞೆಗಳಲ್ಲಿ ಅಥವಾ ಏಕೀಕರಣ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರತ್ಯೇಕವಾದ ಮತ್ತು ಸ್ವತಂತ್ರ ಪರಿಸರವನ್ನು ಸುಲಭವಾಗಿ ನಿಯೋಜಿಸಲು ಮತ್ತು ಕಿತ್ತುಹಾಕಲು Pulumi ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

ನೀವು GitHub ಅನ್ನು ಬಳಸಿದರೆ, ನಂತರ Pulumi ನೀಡುತ್ತದೆ GitHub ಅಪ್ಲಿಕೇಶನ್, ಇದು ನಿಮ್ಮ CI ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ವಿನಂತಿಗಳನ್ನು ಎಳೆಯಲು ಸ್ವೀಕಾರ ಪರೀಕ್ಷೆಯನ್ನು ಸಂಪರ್ಕಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. GitHub ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಪುಲುಮಿ ನಿಮ್ಮ CI ಮತ್ತು ಪೂಲ್ ವಿನಂತಿಗಳಿಗೆ ಮೂಲಸೌಕರ್ಯ ಪೂರ್ವವೀಕ್ಷಣೆಗಳು, ನವೀಕರಣಗಳು ಮತ್ತು ಪರೀಕ್ಷಾ ಫಲಿತಾಂಶಗಳ ಕುರಿತು ಮಾಹಿತಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ:

ನಿಮ್ಮ ಪ್ರಮುಖ ಸ್ವೀಕಾರ ಪರೀಕ್ಷೆಗಳಿಗೆ ನೀವು Pulumi ಅನ್ನು ಬಳಸಿದಾಗ, ನೀವು ಹೊಸ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ ಅದು ತಂಡದ ಉತ್ಪಾದಕತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಬದಲಾವಣೆಗಳ ಗುಣಮಟ್ಟದಲ್ಲಿ ನಿಮಗೆ ವಿಶ್ವಾಸವನ್ನು ನೀಡುತ್ತದೆ.

ಫಲಿತಾಂಶ

ಈ ಲೇಖನದಲ್ಲಿ, ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಬಳಸುವುದರ ಮೂಲಕ, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಲ್ಲಿ ಉಪಯುಕ್ತವಾದ ಅನೇಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ತಂತ್ರಗಳು ನಮಗೆ ಲಭ್ಯವಾಗುತ್ತವೆ ಎಂದು ನಾವು ನೋಡಿದ್ದೇವೆ. ಅವು ಘಟಕ ಪರೀಕ್ಷೆ, ಏಕೀಕರಣ ಪರೀಕ್ಷೆ ಮತ್ತು ವ್ಯಾಪಕವಾದ ರನ್‌ಟೈಮ್ ಪರೀಕ್ಷೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಹೇಗೆ ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಅಥವಾ ನಿಮ್ಮ CI ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುವುದು ಸುಲಭ.

ಪುಲುಮಿ - ಓಪನ್ ಸೋರ್ಸ್ ಸಾಫ್ಟ್‌ವೇರ್, ಬಳಸಲು ಉಚಿತ ಮತ್ತು ನಿಮ್ಮ ನೆಚ್ಚಿನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಮತ್ತು ಮೋಡಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ - ಇಂದು ಪ್ರಯತ್ನಿಸಿ!

→ ಮೊದಲ ಭಾಗ

ಮೂಲ: www.habr.com

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