🥇ಜೆಂಕಿನ್ಸ್ ಕೆಲಸದಲ್ಲಿ ಡೈನಾಮಿಕ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಅಥವಾ ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಬಳಕೆದಾರ ಸ್ನೇಹಿಯಾಗಿ ಮಾಡುವುದು ಹೇಗೆ

ಶುಭ ದಿನ, ಹಬ್ರ್!

ಇಂದು ನಾನು ಬಳಸುವ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೇನೆ ಸಕ್ರಿಯ ಆಯ್ಕೆಗಳ ಪ್ಲಗಿನ್ ಕಾರ್ಯವನ್ನು ಮಾಡಿ ಜೆಂಕಿನ್ಸ್ ಅತ್ಯಂತ ಏಕೀಕೃತ ಮತ್ತು ಬಳಕೆದಾರ ಸ್ನೇಹಿ.

ಪರಿಚಯ

DevOps ನಂತಹ ಸಂಕ್ಷೇಪಣವು ಇನ್ನು ಮುಂದೆ IT ಸಮುದಾಯಕ್ಕೆ ಹೊಸದೇನಲ್ಲ. ಅನೇಕ ಜನರಿಗೆ, "DevOps" ಎಂಬ ಪದಗುಚ್ಛವು ಕೆಲವು ರೀತಿಯ ಮ್ಯಾಜಿಕ್ ಬಟನ್‌ಗೆ ಸಂಬಂಧಿಸಿದೆ, ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ, ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಮತ್ತು ಪರೀಕ್ಷಿಸಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಬದಲಾಗುತ್ತದೆ (ಎಲ್ಲವೂ ಹೆಚ್ಚು ಜಟಿಲವಾಗಿದೆ, ಆದರೆ ನಾವು ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ಅಮೂರ್ತರಾಗಿದ್ದೇವೆ).

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

ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಬಳಸುತ್ತೇವೆ ಜೆಂಕಿನ್ಸ್.

ಉದ್ದೇಶ

ನಿರ್ದಿಷ್ಟ ಆವೃತ್ತಿಯ ಆಯ್ದ ಮೈಕ್ರೋಸರ್ವಿಸ್‌ನ ನಿರ್ಮಾಣ ಮತ್ತು (ಅಥವಾ) ನಿಯೋಜನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಅನುಕೂಲಕರ ಜೆಂಕಿನ್ಸ್ ಕೆಲಸವನ್ನು ರಚಿಸಿ.

ಇನ್ಪುಟ್ ಡೇಟಾ

ನಾವು ವಿವಿಧ ಮೈಕ್ರೋ ಸರ್ವಿಸ್‌ಗಳ ಮೂಲ ಕೋಡ್ ಹೊಂದಿರುವ ಹಲವಾರು ರೆಪೊಸಿಟರಿಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ.

ನಿಯತಾಂಕಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಕೆಳಗಿನ ನಿಯತಾಂಕಗಳನ್ನು ನಮ್ಮ ಕೆಲಸಕ್ಕೆ ಇನ್‌ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸಬೇಕು:

ಕೆಲಸವನ್ನು ರನ್ ಮಾಡುವಾಗ ನಾವು ನಿರ್ಮಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಬಯಸುವ ಮೈಕ್ರೋ ಸರ್ವಿಸ್ ಕೋಡ್‌ನೊಂದಿಗೆ ರೆಪೊಸಿಟರಿಯ URL.
ನಿರ್ಮಾಣವು ಸಂಭವಿಸುವ ಬದ್ಧತೆಯ ID.

ಹೇಗಿದೆಯೋ ಹಾಗೆ

ಈ ಕಾರ್ಯವನ್ನು ಸಾಧಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದ ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ರಚಿಸುವುದು.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಬಳಕೆದಾರರು ರೆಪೊಸಿಟರಿ ಮತ್ತು ಕಮಿಟ್ ಐಡಿಗೆ ಮಾರ್ಗವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಮೂದಿಸಬೇಕಾಗುತ್ತದೆ, ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಅನುಕೂಲಕರವಾಗಿಲ್ಲ ಎಂದು ನೀವು ನೋಡುತ್ತೀರಿ.

ಇರುವಂತೆ

ಈಗ ಅದರ ಎಲ್ಲಾ ಅನುಕೂಲಗಳನ್ನು ಪರಿಗಣಿಸಲು ಮತ್ತೊಂದು ರೀತಿಯ ನಿಯತಾಂಕಗಳನ್ನು ಪ್ರಯತ್ನಿಸೋಣ.
ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಟೈಪ್ ಚಾಯ್ಸ್ ಪ್ಯಾರಾಮೀಟರ್ನೊಂದಿಗೆ ರಚಿಸೋಣ, ಎರಡನೆಯದು - ಸಕ್ರಿಯ ಆಯ್ಕೆಗಳು ರಿಯಾಕ್ಟಿವ್ ರೆಫರೆನ್ಸ್ ಪ್ಯಾರಾಮೀಟರ್. ಆಯ್ಕೆಯ ಪ್ರಕಾರದೊಂದಿಗೆ ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ, ನಮ್ಮ ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳ ಕೋಡ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿರುವ ರೆಪೊಸಿಟರಿಗಳ ಹೆಸರನ್ನು ನಾವು ಆಯ್ಕೆಗಳ ಕ್ಷೇತ್ರದಲ್ಲಿ ಹಸ್ತಚಾಲಿತವಾಗಿ ಸೇರಿಸುತ್ತೇವೆ.

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

ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್ ಯಾವ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ (test1 ಅಥವಾ test2) ಅನ್ನು ಅವಲಂಬಿಸಿ ಎರಡನೇ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಮೌಲ್ಯಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ತುಂಬಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಪ್ರತಿ ರೆಪೊಸಿಟರಿಯು ತನ್ನದೇ ಆದ ಕಮಿಟ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಸಕ್ರಿಯ ಆಯ್ಕೆಗಳು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಉಲ್ಲೇಖ ನಿಯತಾಂಕ ಭರ್ತಿ ಮಾಡಲು ಕೆಳಗಿನ ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊಂದಿದೆ:

ಹೆಸರು - ಪ್ಯಾರಾಮೀಟರ್ ಹೆಸರು.
ಸ್ಕ್ರಿಪ್ಟ್ - ಉಲ್ಲೇಖಿತ ಪ್ಯಾರಾಮೀಟರ್ ಕ್ಷೇತ್ರದಿಂದ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿದಾಗ ಪ್ರತಿ ಬಾರಿ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಕೋಡ್ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು test1 ಮತ್ತು test2 ನಡುವೆ ಆಯ್ಕೆ ಮಾಡಿದಾಗ).
ವಿವರಣೆ - ನಿಯತಾಂಕದ ಸಂಕ್ಷಿಪ್ತ ವಿವರಣೆ.
ಆಯ್ಕೆಯ ಪ್ರಕಾರ - ಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಕ ಹಿಂದಿರುಗಿದ ವಸ್ತುವಿನ ಪ್ರಕಾರ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು html ಕೋಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ).
ಉಲ್ಲೇಖಿತ ನಿಯತಾಂಕ - ನಿಯತಾಂಕದ ಹೆಸರು, ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿದಾಗ, ಸ್ಕ್ರಿಪ್ಟ್ ವಿಭಾಗದಿಂದ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಈ ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ಪ್ರಮುಖ ಕ್ಷೇತ್ರವನ್ನು ಭರ್ತಿ ಮಾಡಲು ನೇರವಾಗಿ ಮುಂದುವರಿಯೋಣ. ನಾವು ಆಯ್ಕೆ ಮಾಡಲು ಎರಡು ರೀತಿಯ ಅನುಷ್ಠಾನವನ್ನು ನೀಡುತ್ತೇವೆ: ಬಳಸುವುದು ಗ್ರೂವಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅಥವಾ ಸ್ಕ್ರಿಪ್ಟ್ಲರ್ ಸ್ಕ್ರಿಪ್ಟ್.
ನಾವು ಮೊದಲನೆಯದನ್ನು ಆರಿಸಿಕೊಳ್ಳುತ್ತೇವೆ, ಏಕೆಂದರೆ ಸ್ಕ್ರಿಪ್ಟ್ಲರ್ ಕೇವಲ ಪ್ಲಗಿನ್ ಆಗಿದ್ದು ಅದು ನೀವು ಹಿಂದೆ ಬರೆದಿರುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಉಳಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಮತ್ತೆ ಕಾಪಿ-ಪೇಸ್ಟ್ ಮಾಡದೆಯೇ ಇತರ ಕಾರ್ಯಗಳಲ್ಲಿ ಬಳಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಆಯ್ದ ರೆಪೊಸಿಟರಿಯಿಂದ ಎಲ್ಲಾ ಕಮಿಟ್‌ಗಳನ್ನು ಪಡೆಯಲು ಗ್ರೂವಿ ಕೋಡ್:

AUTH = "логин и пароль в Base64"                           
GIT_URL = "url до вашей SCM (https://bitbucket.org/)"                       
PROJECT_NAME = "имя проектной области, где находятся репозитории"

def htmlBuild() {
    html = """
            <html>
            <head>
            <meta charset="windows-1251">
            <style type="text/css">
            div.grayTable {
            text-align: left;
            border-collapse: collapse;
            }
            .divTable.grayTable .divTableCell, .divTable.grayTable .divTableHead {
            padding: 0px 3px;
            }
            .divTable.grayTable .divTableBody .divTableCell {
            font-size: 13px;
            }
            </style>
            </head>
            <body>
        """

    def commitOptions = ""
    getCommitsForMicroservice(MICROSERVICE_NAME).each {
        commitOptions += "<option style='font-style: italic' value='COMMIT=${it.getKey()}'>${it}</option>"
    }
    html += """<p style="display: inline-block;">
        <select id="commit_id" size="1" name="value">
            ${commitOptions}
        </select></p></div>"""

    html += """
            </div>
            </div>
            </div>
            </body>
            </html>
         """
    return html
}

def getCommitsForMicroservice(microserviceRepo) {
    def commits = [:]
    def endpoint = GIT_URL + "/rest/api/1.0/projects/${PROJECT_NAME}/repos/${microserviceRepo}/commits"
    def conn = new URL(endpoint).openConnection()
    conn.setRequestProperty("Authorization", "Basic ${AUTH}")
    def response = new groovy.json.JsonSlurper().parseText(conn.content.text)
    response.values.each {
        commits.put(it.displayId, it.message)
    }
    return commits
}

return htmlBuild()

ವಿವರಗಳಿಗೆ ಹೋಗದೆ, ಈ ಕೋಡ್ ಮೈಕ್ರೋಸರ್ವೀಸ್ ಹೆಸರನ್ನು (MICROSERVICE_NAME) ಇನ್‌ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ bitbucket (ವಿಧಾನ ಗೆಟ್ ಕಮಿಟ್ಸ್ ಫಾರ್ ಮೈಕ್ರೋ ಸರ್ವೀಸ್) ಅದರ API ಅನ್ನು ಬಳಸಿ, ಮತ್ತು ನೀಡಿರುವ ಮೈಕ್ರೋ ಸರ್ವೀಸ್‌ಗಾಗಿ ಎಲ್ಲಾ ಕಮಿಟ್‌ಗಳ ಐಡಿ ಮತ್ತು ಬದ್ಧತೆಯ ಸಂದೇಶವನ್ನು ಪಡೆಯುತ್ತದೆ.
ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಈ ಕೋಡ್ ಪುಟದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುವ html ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ನಿರ್ಮಿಸಿ ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ, ಆದ್ದರಿಂದ ನಾವು ಬಿಟ್‌ಬಕೆಟ್‌ನಿಂದ ಸ್ವೀಕರಿಸಿದ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ಸುತ್ತುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸೇರಿಸುತ್ತೇವೆ.

ಎಲ್ಲಾ ಹಂತಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ನಾವು ಅಂತಹ ಸುಂದರವಾದ ಪುಟವನ್ನು ಪಡೆಯಬೇಕು ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ನಿರ್ಮಿಸಿ.

ನೀವು test1 ಮೈಕ್ರೊ ಸರ್ವೀಸ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿದರೆ:

ನೀವು test2 ಮೈಕ್ರೊ ಸರ್ವೀಸ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿದರೆ:

ಪ್ರತಿ ಬಾರಿಯೂ url ಅನ್ನು ನಕಲಿಸುವುದಕ್ಕಿಂತ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಕಮಿಟ್ ಐಡಿಯನ್ನು ಹುಡುಕುವುದಕ್ಕಿಂತ ಬಳಕೆದಾರರು ಈ ರೀತಿಯಲ್ಲಿ ನಿಮ್ಮ ಕಾರ್ಯದೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಇದು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿರುತ್ತದೆ ಎಂದು ಒಪ್ಪಿಕೊಳ್ಳಿ.

ಪಿಎಸ್ ಈ ಲೇಖನವು ಅತ್ಯಂತ ಸರಳೀಕೃತ ಉದಾಹರಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಈ ರೂಪದಲ್ಲಿ ಪ್ರಾಯೋಗಿಕವಾಗಿ ಬಳಕೆಯಾಗದಿರಬಹುದು, ಏಕೆಂದರೆ ಅಸೆಂಬ್ಲಿಗಳು ಹಲವಾರು ವಿಭಿನ್ನ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿವೆ, ಆದರೆ ಈ ಲೇಖನದ ಉದ್ದೇಶವು ಉಪಕರಣವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುವುದು, ಆದರೆ ಕೆಲಸ ಮಾಡುವ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ.

ಪಿಎಸ್ಎಸ್ ನಾನು ಮೊದಲೇ ಬರೆದಂತೆ, ಈ ಲೇಖನವು ಉಪಯುಕ್ತವಾಗಿದ್ದರೆ, ಮುಂದಿನದು ಅದರ ಬಗ್ಗೆ ಇರುತ್ತದೆ ಕೋಡ್ ಮೂಲಕ ಜೆಂಕಿನ್ಸ್ ಕಾರ್ಯಗಳ ಡೈನಾಮಿಕ್ ಕಾನ್ಫಿಗರೇಶನ್.

ಮೂಲ: www.habr.com