ਮੈਂ ਹਾਲ ਹੀ ਵਿੱਚ DevOps ਸੰਸਾਰ ਵਿੱਚ ਇੱਕ ਗੈਰ-ਪ੍ਰਸਿੱਧ ਜਾਨਵਰ ਨੂੰ ਦੇਖਿਆ, Azure DevOps ਪਾਈਪਲਾਈਨਾਂ। ਮੈਨੂੰ ਤੁਰੰਤ ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਕਿਸੇ ਸਪੱਸ਼ਟ ਨਿਰਦੇਸ਼ਾਂ ਜਾਂ ਲੇਖਾਂ ਦੀ ਘਾਟ ਮਹਿਸੂਸ ਹੋਈ, ਮੈਨੂੰ ਨਹੀਂ ਪਤਾ ਕਿ ਇਹ ਕਿਸ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ, ਪਰ ਮਾਈਕ੍ਰੋਸਾਫਟ ਕੋਲ ਟੂਲ ਨੂੰ ਪ੍ਰਸਿੱਧ ਬਣਾਉਣ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਨ ਲਈ ਕੁਝ ਹੈ। ਅੱਜ ਅਸੀਂ Azure ਕਲਾਉਡ ਦੇ ਅੰਦਰ ਆਟੋਮੇਟਿਡ ਟੈਸਟਿੰਗ ਲਈ ਇੱਕ ਪਾਈਪਲਾਈਨ ਬਣਾਵਾਂਗੇ।

ਇਸ ਲਈ, ਕੰਮ:
ਇੱਕ ਸਾਫਟਵੇਅਰ ਹੈ ਜੋ ਉਸੇ Azure DevOps ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਇੱਕ WIX ਪ੍ਰੋਜੈਕਟ ਤੋਂ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ। ਜੇਕਰ ਦਿਲਚਸਪੀ ਹੈ, ਤਾਂ ਮੈਂ ਇਸ ਟੂਲ ਬਾਰੇ ਵੀ ਲਿਖਾਂਗਾ। ਅਸਲ ਵਿੱਚ, ਇਹ Windows ਇੰਸਟਾਲਰ ਬਣਾਉਣ ਦਾ ਇੱਕ ਵਧੇਰੇ ਸਵੈਚਾਲਿਤ ਤਰੀਕਾ ਹੈ, ਜੋ ਕਿ ਸਟੈਂਡਰਡ InstallShield ਦੀ ਥਾਂ ਲੈਂਦਾ ਹੈ। ਇਸ ਲਈ, ਸਾਡਾ ਸਾਫਟਵੇਅਰ ਸਫਲਤਾਪੂਰਵਕ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਆਰਟੀਫੈਕਟ, ਇੱਕ setup.exe, ਤਿਆਰ ਕਰਦਾ ਹੈ, ਜੋ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਿਸਟਮ ਵਿੱਚ ਸਥਾਪਿਤ ਕਰਦਾ ਹੈ। Windowsਤੁਹਾਨੂੰ ਇਸ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਪ੍ਰੋਡਕਸ਼ਨ ਵਰਗੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਵਿੱਚ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਉੱਥੇ ਟੈਸਟਿੰਗ ਟੀਮ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਗਏ ਆਟੋਮੇਟਿਡ ਟੈਸਟਾਂ ਦੀ ਨਕਲ ਕਰਨੀ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਚਲਾਉਣਾ ਹੈ, ਅਤੇ ਨਤੀਜੇ ਇਕੱਠੇ ਕਰਨੇ ਹਨ ਤਾਂ ਜੋ ਇਹ ਪਤਾ ਲਗਾਇਆ ਜਾ ਸਕੇ ਕਿ ਬ੍ਰਾਂਚ ਚੰਗੀ ਹੈ ਜਾਂ ਮਾੜੀ, ਮਿਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ। ਇਹ ਬਿਲਕੁਲ GitLab ਵਾਂਗ ਹੈ, ਸਿਰਫ਼ ਗਧੇ ਰਾਹੀਂ।

ਇੱਕ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਵਾਤਾਵਰਨ ਵਜੋਂ ਜਿੱਥੇ ਅਸੀਂ ਆਪਣੇ ਟੈਸਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਾਂਗੇ, ਅਸੀਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ Azure DevTest Labs ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, Azure ਸਬਸਕ੍ਰਿਪਸ਼ਨਾਂ ਵਿੱਚ ਇੱਕ ਖਾਸ ਇਕਾਈ, ਜੋ ਇਸ ਉਦੇਸ਼ ਲਈ ਬਣਾਈ ਗਈ ਸੀ ਤਾਂ ਜੋ ਇਸ ਵਿੱਚ ਵਾਜਬ ਪੈਸਿਆਂ ਲਈ ਹਰ ਤਰ੍ਹਾਂ ਦੇ ਟੈਸਟਿੰਗ ਬਕਵਾਸ ਨੂੰ ਚਲਾਇਆ ਜਾ ਸਕੇ।

1. ਕਲਾਉਡ ਸਾਈਡ 'ਤੇ ਏਕੀਕਰਣ

ਪਹਿਲਾਂ, ਸਾਨੂੰ ਆਪਣੀਆਂ DevTest ਲੈਬਾਂ ਨੂੰ Azure DevOps ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਜਿਸ ਲਈ ਸਾਨੂੰ ਇੱਕ ਖਾਸ ਸੇਵਾ ਪ੍ਰਿੰਸੀਪਲ ਦੀ ਲੋੜ ਹੈ, ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਇੱਕ ਸੇਵਾ ਖਾਤਾ ਜੋ ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ ਕਲਾਊਡ 'ਤੇ ਜਾਣ ਅਤੇ ਆਪਣੇ ਲਈ ਉੱਥੇ ਸਰੋਤ ਬਣਾਉਣ/ਮਿਟਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਗਾਹਕੀ 'ਤੇ ਜਾਓ ਅਤੇ Azure ਐਕਟਿਵ ਡਾਇਰੈਕਟਰੀ ਸੇਵਾ ਲੱਭੋ

ਐਪ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਲੱਭੋ ਅਤੇ ਨਵੀਂ ਰਜਿਸਟ੍ਰੇਸ਼ਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ, ਇਹ ਸਾਡੀ ਸੇਵਾ ਪ੍ਰਿੰਸੀਪਲ ਬਣਾਏਗਾ। ਮੈਂ ਇਸ ਬਾਰੇ ਵਿਸਤਾਰ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗਾ ਕਿ ਇਸਨੂੰ ਬਣਾਉਣ ਵੇਲੇ ਕਿਹੜੀਆਂ ਸੈਟਿੰਗਾਂ ਦੀ ਚੋਣ ਕਰਨੀ ਹੈ; ਇਹ ਵੱਖ-ਵੱਖ ਗਾਹਕੀਆਂ ਲਈ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ।

ਹੁਣ ਸਾਨੂੰ ਆਪਣੇ ਸਰਵਿਸ ਡਾਇਰੈਕਟਰ ਨੂੰ ਅਧਿਕਾਰ ਦੇਣ ਦੀ ਲੋੜ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਤੇ ਜਾਓ, ਇੱਕ ਕੁੰਜੀ ਦੇ ਨਾਲ ਆਈਕਨ. ਸਾਡੀ ਗਾਹਕੀ ਚੁਣੋ।

ਅੱਗੇ, ਐਕਸੈਸ ਕੰਟਰੋਲ ਵਿੱਚ, ਰੋਲ ਅਸਾਈਨਮੈਂਟ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਤੁਹਾਡੇ ਵੱਲੋਂ ਹੁਣੇ ਬਣਾਏ ਗਏ ਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਖਾਤੇ ਦੀ ਖੋਜ ਕਰੋ। ਅਸੀਂ Contributor ਰੋਲ ਦਿੰਦੇ ਹਾਂ, ਇਹ ਕਾਫੀ ਹੈ।

ਅੱਗੇ, ਅਸੀਂ Azure AD ਵਿੱਚ ਸਾਡੇ ਸਰਵਿਸ ਪ੍ਰਿੰਸੀਪਲ ਕੋਲ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਖੋਲ੍ਹਦੇ ਹਾਂ। ਬਾਅਦ ਵਿੱਚ, ਸਾਨੂੰ ਸਾਰੀਆਂ ਆਈਡੀਜ਼ ਦੀ ਲੋੜ ਪਵੇਗੀ ਜੋ ਉੱਥੇ ਹਨ, ਅਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਬਚਾ ਲਵਾਂਗੇ।

ਇਹ ਸਾਡੀਆਂ ਪੋਰਟਲ ਸੈਟਿੰਗਾਂ ਨੂੰ ਸਮਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਅਸੀਂ Azure DevOps 'ਤੇ ਅੱਗੇ ਵਧਦੇ ਹਾਂ।

2. Azure DevOps ਵਾਲੇ ਪਾਸੇ ਏਕੀਕਰਣ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਸੈਟਿੰਗਾਂ 'ਤੇ ਜਾਵਾਂਗੇ ਅਤੇ ਸਰਵਿਸ ਕਨੈਕਸ਼ਨ ਚੁਣਾਂਗੇ। Azure ਸਰੋਤ ਪ੍ਰਬੰਧਕ ਕਿਸਮ ਦਾ ਇੱਕ ਨਵਾਂ ਤੱਤ ਬਣਾਓ।

ਹੁਣ ਸਾਨੂੰ ਉਹਨਾਂ ਸਾਰੀਆਂ IDs ਦੀ ਲੋੜ ਪਵੇਗੀ ਜੋ ਅਸੀਂ ਹੇਠਾਂ ਲਿਖੀਆਂ ਹਨ। ਸਰਵਿਸ ਕੁਨੈਕਸ਼ਨ ਡਾਇਲਾਗ ਦੇ ਪੂਰੇ ਸੰਸਕਰਣ ਦੀ ਵਰਤੋਂ 'ਤੇ ਕਲਿੱਕ ਕਰੋ। ਅਤੇ ਅਸੀਂ ਸਰਵਿਸ ਪ੍ਰਿੰਸੀਪਲ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਸਾਰਾ ਡਾਟਾ ਦਰਜ ਕਰਦੇ ਹਾਂ। ਤਸਦੀਕ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਜੇਕਰ ਸਭ ਕੁਝ ਠੀਕ ਹੈ, ਤਾਂ ਕਨੈਕਸ਼ਨ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ। ਹੁਣ ਸਾਡੀਆਂ ਪਾਈਪਲਾਈਨਾਂ ਇਸਦੀ ਵਰਤੋਂ ਕਲਾਉਡ ਨਾਲ ਜੁੜਨ ਲਈ ਕਰ ਸਕਦੀਆਂ ਹਨ।

3. ਪਾਈਪਲਾਈਨ ਬਣਾਉਣਾ

ਆਓ ਹੁਣ ਮਜ਼ੇਦਾਰ ਹਿੱਸੇ 'ਤੇ ਪਹੁੰਚੀਏ, ਪਾਈਪਲਾਈਨ ਖੁਦ ਬਣਾਉਣਾ. ਪਾਈਪਲਾਈਨਾਂ-ਬਿਲਡ ਮੀਨੂ ਖੋਲ੍ਹੋ

ਸਾਨੂੰ ਇੱਕ ਨਵੀਂ ਬਿਲਡ ਬਣਾਉਣ ਲਈ ਇੱਕ ਮੀਨੂ ਨਾਲ ਸਵਾਗਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਮੂਲ ਰੂਪ ਵਿੱਚ ਇੱਕ ਢੁਕਵੀਂ ਸੰਰਚਨਾ ਦੇ ਨਾਲ ਸਾਡੇ ਲਈ ਇੱਕ YAML ਫਾਈਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇਗਾ। ਅਸੀਂ ਨਿਮਰਤਾ ਨਾਲ ਇਸ ਨੂੰ ਅਸਵੀਕਾਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਕਲਾਸਿਕ ਵਿਕਲਪ ਦੀ ਚੋਣ ਕਰਦੇ ਹਾਂ। ਇਹ ਸਮਝਣ ਯੋਗ ਹੈ ਕਿ ਮਾਈਕਰੋਸੌਫਟ ਸਭ ਕੁਝ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਲੋਕ ਕਰਦੇ ਹਨ ਅਤੇ ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ YAML ਦੁਆਰਾ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਅਨੁਕੂਲਿਤ ਕਰਨ ਦਾ ਮੌਕਾ ਦੇਣਾ ਚਾਹੁੰਦਾ ਹੈ, ਪਰ ਬਹੁਤ ਘੱਟ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਮੋਡਿਊਲਾਂ ਦੀ ਵਿਹਾਰਕ ਅਯੋਗਤਾ ਸਾਨੂੰ ਦੱਸਦੀ ਹੈ ਕਿ ਇਸ ਕਾਰਜਸ਼ੀਲਤਾ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਹੁਤ ਜਲਦੀ ਹੈ।

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

ਇਸ ਲਈ, + 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਆਪਣੇ ਆਪ ਨੂੰ ਇੱਕ ਖਾਸ ਮੋਡੀਊਲ ਸਟੋਰ ਵਿੱਚ ਲੱਭੋ, ਜਿੱਥੋਂ ਸਾਨੂੰ ਸੂਚੀ ਵਿੱਚੋਂ ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ।

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਪਾਈਪਲਾਈਨ ਕਾਰਜਾਂ ਦੀ ਸੰਰਚਨਾ ਸ਼ੁਰੂ ਕਰੀਏ, ਸਾਨੂੰ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕਈ ਫਾਈਲਾਂ ਬਣਾਉਣ ਅਤੇ ਪਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਸਾਡੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦਾ ARM ਟੈਂਪਲੇਟ ਹੋਵੇਗਾ, ਜਿਸ ਨੂੰ ਅਸੀਂ Azure DevTest Labs ਵਿੱਚ ਤਿਆਰ ਕਰਾਂਗੇ, ਮਸ਼ੀਨ ਬਣਨ ਤੋਂ ਬਾਅਦ ਇਸ ਦਾ IP ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਸਕ੍ਰਿਪਟ ਅਤੇ, ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਸਾਡੇ ਟੈਸਟਾਂ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਜਾਂ ਅਸੀਂ ਕੀ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਮੇਜਬਾਨ.

4. ARM ਟੈਂਪਲੇਟ ਦੀ ਉਤਪੱਤੀ

ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਇਸਦੇ ਲਈ ਇੱਕ ਟੈਂਪਲੇਟ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ, ਇੱਕ json ਫਾਈਲ, ਜਿਸ ਨੂੰ ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਕੋਡ ਵਿੱਚ ਪਾਵਾਂਗੇ ਤਾਂ ਜੋ ਪਾਈਪਲਾਈਨ ਇਸਨੂੰ ਉੱਥੋਂ ਪੜ੍ਹ ਸਕੇ।

ਅਸੀਂ ਆਪਣੀ ਲੈਬ ਵਿੱਚ ਜਾਂਦੇ ਹਾਂ ਅਤੇ ਫਾਰਮੂਲੇ (ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਅਧਾਰ) ਮੀਨੂ ਲੱਭਦੇ ਹਾਂ, ਇੱਕ ਨਵਾਂ ਬਣਾਓ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।

ਸਾਡਾ ਸਵਾਗਤ ਚਿੱਤਰਾਂ ਦੀ ਇੱਕ ਲੰਬੀ ਸੂਚੀ, ਮਸ਼ੀਨ ਦੇ ਆਕਾਰ ਦੀ ਚੋਣ, ਅਤੇ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਬਣਾਉਣ ਵੇਲੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਅਸੀਂ ਇਸ ਪੜਾਅ 'ਤੇ ਧਿਆਨ ਨਹੀਂ ਦੇਵਾਂਗੇ; ਅਸੀਂ ਸਿੱਧੇ ਮਸ਼ੀਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਅੰਤਿਮ ਆਈਟਮ 'ਤੇ ਚਲੇ ਜਾਵਾਂਗੇ, ਅਰਥਾਤ, ਕਲਾਕ੍ਰਿਤੀਆਂ। ਤੁਸੀਂ ਆਪਣੇ ਵਾਤਾਵਰਣ ਲਈ ਲੋੜੀਂਦੀ ਕਿਸੇ ਵੀ ਸੰਰਚਨਾ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਣ ਵਜੋਂ, ਮੈਂ ਇੱਕ ਮਸ਼ੀਨ ਜੋੜ ਰਿਹਾ ਹਾਂ ਡੋਮੇਨ ਨਾਮ ਮੈਂ ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰਸ਼ਾਸਕ ਦੇ ਤੌਰ 'ਤੇ ਇੱਕ ਸੇਵਾ ਖਾਤਾ ਜੋੜਦਾ ਹਾਂ ਤਾਂ ਜੋ ਪਾਈਪਲਾਈਨ ਫਿਰ ਇਸ ਖਾਤੇ ਦੇ ਅਧੀਨ ਇਸ ਮਸ਼ੀਨ ਵਿੱਚ ਲੌਗਇਨ ਕਰ ਸਕੇ। ਇਹ ਸਭ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਕੋਡ ਦੀ ਸਫਲਤਾਪੂਰਵਕ ਜਾਂਚ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਆਰਟੀਫੈਕਟ ਦੀ ਲੋੜ ਹੈ, ਜਿਸ ਬਾਰੇ ਅਸੀਂ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਚਰਚਾ ਕਰਾਂਗੇ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਅਸੀਂ ਜਿਸ ਸੌਫਟਵੇਅਰ ਦੀ ਜਾਂਚ ਕਰ ਰਹੇ ਹਾਂ ਉਸਦਾ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਸਾਡੀ ਮਸ਼ੀਨ 'ਤੇ ਸਥਾਪਿਤ ਹੈ, ਅਸੀਂ "Azure Pipelines Artifact ਡਾਊਨਲੋਡ ਕਰੋ ਅਤੇ ਸਕ੍ਰਿਪਟ ਚਲਾਓ" ਆਰਟੀਫੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਯਾਦ ਰੱਖੋ ਜਦੋਂ ਮੈਂ ਸ਼ੁਰੂ ਵਿੱਚ ਜ਼ਿਕਰ ਕੀਤਾ ਸੀ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਇੰਸਟੌਲਰ ਦੇ ਨਾਲ ਇੱਕ ਬਿਲਡ ਕਿਤੇ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ? ਹੁਣ ਸਾਨੂੰ ਵਰਚੁਅਲ ਮਸ਼ੀਨ, ਜਾਂ ਹੋਰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, ਟੈਂਪਲੇਟ ਨੂੰ ਇਹ ਦੱਸਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਉਹ ਜਾ ਕੇ ਇਸ ਆਰਟੀਫੈਕਟ ਨੂੰ ਫੜ ਲਵੇ। ਅਤੇ ਸਿਰਫ਼ ਇਸਨੂੰ ਫੜੋ ਹੀ ਨਹੀਂ, ਸਗੋਂ ਇਸਨੂੰ ਸਥਾਪਿਤ ਵੀ ਕਰੋ, ਜਿਸ ਲਈ ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ, ਬਿਲਡ ਨਾਮ ਅਤੇ ਗੁਪਤ ਕੁੰਜੀ ਨੂੰ ਦਰਸਾਉਂਦੇ ਵਿਸ਼ੇਸ਼ ਖੇਤਰ ਭਰਦੇ ਹਾਂ। ਗੁਪਤ ਕੁੰਜੀ, ਜਿਵੇਂ ਕਿ ਸਾਰੇ ਸਮਾਨ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ, ਖਾਤੇ ਵਿੱਚ ਤਿਆਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ - ਇਸ ਮਾਮਲੇ ਵਿੱਚ, Azure DevOps ਵਿੱਚ - ਅਤੇ ਤੁਹਾਡੀ ਲੈਬ ਵਿੱਚ Secrets ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇੱਥੇ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਚੇਤਾਵਨੀ ਹੈ: ਅਸੀਂ ਇਸਨੂੰ Secrets ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਾਂਗੇ, ਪਰ ਟੈਂਪਲੇਟ ਪਰਵਾਹ ਨਹੀਂ ਕਰੇਗਾ। ਇਸਨੂੰ ਪਾਈਪਲਾਈਨ ਦੇ ਅੰਦਰ ਇੱਕ ਵੱਖਰੇ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਲਾਂਚ ਕੀਤਾ ਜਾਵੇਗਾ, ਇਸ ਲਈ ਸਾਨੂੰ ਟੈਂਪਲੇਟ ਵਿੱਚ ਦੁਬਾਰਾ ਗੁਪਤ ਕੁੰਜੀ ਨੂੰ ਹੱਥੀਂ ਦਰਜ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।

ਇਕ ਹੋਰ ਕਲਾਤਮਕ ਚੀਜ਼ ਜਿਸ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਉਹ ਹੈ "ਵਿਨਆਰਐਮ ਕੌਂਫਿਗਰ ਕਰੋ"; ਸਾਨੂੰ ਮਸ਼ੀਨ ਤੱਕ ਅਗਲੀ ਪਹੁੰਚ ਲਈ ਇਸਦੀ ਲੋੜ ਪਵੇਗੀ। ਇੱਥੇ ਸਿਰਫ਼ ਇੱਕ ਪੈਰਾਮੀਟਰ ਹੈ, ਹੋਸਟ-ਨਾਂ। ਕਿਉਂਕਿ ਅਸੀਂ ਇਸਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਨਹੀਂ ਜਾਣਦੇ ਹਾਂ, ਅਸੀਂ %COMPUTERNAME% ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।

ਇਸ ਲਈ ਅਸੀਂ ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਕਲਾਕ੍ਰਿਤੀਆਂ ਨੂੰ ਜੋੜਿਆ ਹੈ, ਆਓ ਅੱਗੇ ਵਧੀਏ ਕਿ ਅਸੀਂ ਇੱਥੇ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਕਿਉਂ ਆਏ ਹਾਂ। ਅਸੀਂ ਉਸੇ ਫਾਰਮੂਲਾ ਬਣਾਉਣ ਵਾਲੀ ਵਿੰਡੋ ਦੇ ਐਡਵਾਂਸਡ ਟੈਬ ਵਿੱਚ ਤਿਆਰ ਕੀਤੇ ARM ਟੈਂਪਲੇਟ ਨੂੰ ਬਾਹਰ ਕੱਢਦੇ ਹਾਂ।

ਅਸੀਂ ਪੰਨੇ ਦੀ ਸਮੱਗਰੀ ਨੂੰ VMtemplate.json ਫਾਈਲ ਵਿੱਚ ਕਾਪੀ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਪ੍ਰੋਜੈਕਟ ਦੇ ਰੂਟ ਵਿੱਚ ਪਾਉਂਦੇ ਹਾਂ। ਸਾਨੂੰ ਹੁਣ ਕਲਾਊਡ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਆਓ ਪਾਈਪਲਾਈਨ 'ਤੇ ਵਾਪਸ ਚੱਲੀਏ।

5. ਪਾਈਪਲਾਈਨ ਸੰਰਚਨਾ

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

ਅੱਗੇ ਅਸੀਂ ਇਕ ਹੋਰ ਮਹੱਤਵਪੂਰਣ ਬਿੰਦੂ ਸਥਾਪਤ ਕਰਦੇ ਹਾਂ. ਕਾਰ ਦੇ ਚੱਲਣ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਇਸਦੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ, ਜਾਂ ਇਸ ਤੋਂ ਬਿਹਤਰ, ਸਾਡੇ ਲਈ ਨਹੀਂ, ਪਰ ਪਾਈਪਲਾਈਨ ਲਈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਬਣਾਉਂਦੇ ਹਾਂ, ਉਦਾਹਰਨ ਲਈ GetLabVMParams.ps1 ਅਤੇ ਇਸਨੂੰ ਉੱਥੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਪਾ ਦਿੰਦੇ ਹਾਂ। ਮੈਂ ਮਾਈਕ੍ਰੋਸਾੱਫਟ ਵੈਬਸਾਈਟ ਤੋਂ ਸਕ੍ਰਿਪਟ ਟੈਕਸਟ ਲਿਆ, ਪਰ ਇਸਨੂੰ ਮੇਰੇ ਵਾਤਾਵਰਣ ਲਈ ਥੋੜ੍ਹਾ ਐਡਜਸਟ ਕੀਤਾ, ਕਿਉਂਕਿ... ਉਸਨੇ PublicIP ਅਤੇ FQDN ਮਸ਼ੀਨਾਂ ਲਈਆਂ। ਮੇਰੇ ਕੋਲ ਨਾ ਤਾਂ ਇੱਕ ਹੈ ਅਤੇ ਨਾ ਹੀ ਦੂਜਾ, ਪਰ ਮੇਰੇ ਕੋਲ ਇੱਕ ਪ੍ਰਾਈਵੇਟਆਈਪੀ ਹੈ, ਜੋ ਪ੍ਰਾਪਤ ਕਰਨਾ ਇੰਨਾ ਆਸਾਨ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਮੈਂ ਇੱਕ ਟੁਕੜਾ ਜੋੜਿਆ ਹੈ।

Param( [string] $labVmId)

$labVmComputeId = (Get-AzureRmResource -Id $labVmId).Properties.ComputeId

# Get lab VM resource group name
$labVmRgName = (Get-AzureRmResource -Id $labVmComputeId).ResourceGroupName

# Get the lab VM Name
$labVmName = (Get-AzureRmResource -Id $labVmId).Name

# Get lab VM public IP address
# $labVMIpAddress = (Get-AzureRmPublicIpAddress -ResourceGroupName $labVmRgName -Name $labVmName).IpAddress

# Get lab VM FQDN
# $labVMFqdn = (Get-AzureRmPublicIpAddress -ResourceGroupName $labVmRgName -Name $labVmName).DnsSettings.Fqdn

# Get lab VM private IP address
$VmNetworkdetails= (((Get-AzureRmVM -ResourceGroupName $labVmRgName -Name $labVmName).NetworkProfile).NetworkInterfaces).Id
$nicname = $VmNetworkdetails.substring($VmNetworkdetails.LastIndexOf("/")+1)
$labVMnetwork = (Get-AzureRmNetworkInterface -Name $nicname -ResourceGroupName $labVmRgName)|Select-Object -ExpandProperty IPConfigurations 
$labVMIpAddress = $labVMnetwork.PrivateIpAddress

# Set a variable labVmRgName to store the lab VM resource group name
Write-Host "##vso[task.setvariable variable=labVmRgName;]$labVmRgName"

# Set a variable labVMIpAddress to store the lab VM Ip address
Write-Host "##vso[task.setvariable variable=labVMIpAddress;]$labVMIpAddress"

# Set a variable labVMFqdn to store the lab VM FQDN name
Write-Host "##vso[task.setvariable variable=labVMFqdn;]$labVMFqdn"

Write-Output $labVMIpAddress

Set-Item wsman:localhostclienttrustedhosts * -Force

ਹਰ ਚੀਜ਼ ਜੋ ਸਕ੍ਰਿਪਟ ਪੜ੍ਹਦੀ ਹੈ, ਸਾਨੂੰ ਸਿਰਫ਼ labVMIpAddress ਵੇਰੀਏਬਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਖੈਰ, ਇਹ ਮੇਰੇ ਲਈ ਹੈ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਦੀ ਲੋੜ ਹੋਵੇ, ਇਸ ਲਈ ਮੈਂ ਕੁਝ ਵੀ ਨਹੀਂ ਮਿਟਾਇਆ ਅਤੇ ਸਿਰਫ ਬੇਲੋੜੀ ਸਮੱਗਰੀ 'ਤੇ ਟਿੱਪਣੀ ਕੀਤੀ ਹੈ।

ਮੈਂ ਸਕ੍ਰਿਪਟ ਦੀ ਆਖਰੀ ਲਾਈਨ ਦੀ ਵਿਆਖਿਆ ਵੀ ਕਰਾਂਗਾ; ਇਹ ਸਾਡੀ ਬਿਲਡ ਮਸ਼ੀਨ ਨੂੰ WinRM ਦੁਆਰਾ ਕਿਸੇ ਵੀ ਹੋਸਟ ਤੱਕ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ.

ਅਗਲਾ ਕਦਮ ਸਾਡੀ ਸ਼ਾਨਦਾਰ ਸਕ੍ਰਿਪਟ ਨੂੰ ਲਾਂਚ ਕਰਨਾ ਹੈ। ਉਸ ਨੂੰ ਕਲਾਉਡ ਨਾਲ ਉਹੀ ਕੁਨੈਕਸ਼ਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ, ਮਸ਼ੀਨ ID ਦੇ ਨਾਲ ਇੱਕ ਇਨਪੁਟ ਵੇਰੀਏਬਲ, ਜੋ ਉਸ ਸਮੇਂ ਤੱਕ ਪਿਛਲੇ ਪੜਾਅ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਿਆ ਜਾਵੇਗਾ। ਕਿਵੇਂ? ਇੱਥੇ ਸਾਨੂੰ ਆਉਟਪੁੱਟ ਵੇਰੀਏਬਲਜ਼ ਵਰਗੀ ਇੱਕ ਸ਼ਾਨਦਾਰ ਚੀਜ਼ ਦਾ ਜ਼ਿਕਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਹਰੇਕ ਪੜਾਅ ਵਿੱਚ ਵੇਰੀਏਬਲਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੋ ਸਕਦੀ ਹੈ ਜੋ ਪਾਈਪਲਾਈਨ ਦੇ ਅਗਲੇ ਪੜਾਵਾਂ 'ਤੇ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਸ ਅਨੁਸਾਰ, ਸਾਡੀ ਸੁਪਰ ਸਕ੍ਰਿਪਟ ਲਈ ਇਹ ਵੇਰੀਏਬਲ labVMIpAddress ਹੋਵੇਗਾ, ਇਸ ਨੂੰ ਦਰਸਾਉਣਾ ਨਾ ਭੁੱਲੋ।

ਅੱਗੇ, ਮੈਂ ਕਾਫ਼ੀ ਸਧਾਰਣ ਚੀਜ਼ਾਂ ਕਰਦਾ ਹਾਂ, ਜੋ ਕਿ, ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕੇਸ ਤੋਂ ਵੱਖਰੇ ਹੋ ਸਕਦੇ ਹਨ. ਮੈਂ ਇੱਕ ਰਿਮੋਟ ਸਕ੍ਰਿਪਟ ਚਲਾ ਰਿਹਾ ਹਾਂ ਅਤੇ ਇੱਕ ਸ਼ੇਅਰ ਬਣਾ ਰਿਹਾ ਹਾਂ, ਜਿਸ ਵਿੱਚ ਮੈਂ ਫਿਰ ਆਪਣੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਅਪਲੋਡ ਕਰਾਂਗਾ।

New-Item “C:test" –type directory
New-SMBShare –Name “test” –Path “C:test”  –FullAccess everyone

ਕਾਰਜਾਂ ਦੇ ਨਾਮ ਤੋਂ ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਅੱਗੇ ਅਸੀਂ ਮਸ਼ੀਨ ਵਿੱਚ ਕੁਝ ਨਮੂਨਾ ਸਕ੍ਰਿਪਟ ਦੀ ਨਕਲ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਹੋਰ ਪੜਾਅ ਵਿੱਚ ਚਲਾਉਂਦੇ ਹਾਂ। ਸਾਡਾ $(labVMIpAddress) ਵੇਰੀਏਬਲ ਸਾਡੇ ਲਈ ਰਿਮੋਟ ਮਸ਼ੀਨ ਦੇ ਪਤੇ ਵਜੋਂ ਉਪਯੋਗੀ ਹੋਵੇਗਾ। ਅੱਗੇ, ਅਸੀਂ "ਬਾਲਾਂ ਤੋਂ ਆਰਟੀਫੈਕਟ ਨੂੰ ਚੁੱਕੋ" ਟਾਸਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਸਾਡੇ ਬਿਲਡ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਾਪੀ ਕਰਦੇ ਹਾਂ, ਫਿਰ ਇਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਬਿਲਡ ਆਰਟੀਫੈਕਟ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਉਸੇ ਸਟੈਂਡਰਡ ਟਾਸਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਜਦੋਂ ਸਾਨੂੰ ਹੁਣ ਕਾਰ ਦੀ ਲੋੜ ਨਹੀਂ ਰਹੇਗੀ, ਆਖਰੀ ਕਦਮ ਇਸ ਨੂੰ ਮਾਰਨਾ ਹੈ। ਮੁੱਖ ਮੁਸ਼ਕਲ, ਜਿਵੇਂ ਕਿ ਲੇਖ ਦੀ ਲੰਬਾਈ ਤੋਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਕਲਾਉਡ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਦੁਆਰਾ ਬਣਾਈ ਗਈ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨਾਲ ਸੰਪਰਕ ਸਥਾਪਤ ਕਰਨਾ ਹੈ, ਫਿਰ ਤੁਸੀਂ ਜਿੰਨਾ ਵੀ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ ਉਨਾ ਮਜ਼ਾ ਲੈ ਸਕਦੇ ਹੋ।

ਇਹ ਮੇਰਾ ਪਹਿਲਾ ਲੇਖ ਹੈ, ਇਸ ਲਈ ਬਹੁਤ ਕਠੋਰਤਾ ਨਾਲ ਨਿਰਣਾ ਨਾ ਕਰੋ, ਟਿੱਪਣੀਆਂ ਦਾ ਸਵਾਗਤ ਹੈ.

ਸਰੋਤ: www.habr.com