ਹੈਲੋ ਹਰ ਕੋਈ!

ਮੈਂ ਇੱਕ ਹੋਟਲ ਬੁਕਿੰਗ ਸੇਵਾ ਲਈ ਇੱਕ DevOps ਇੰਜੀਨੀਅਰ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹਾਂ। Ostrovok.ru. ਇਸ ਲੇਖ ਵਿੱਚ ਮੈਂ ਜਵਾਬਦੇਹ ਭੂਮਿਕਾਵਾਂ ਦੀ ਜਾਂਚ ਵਿੱਚ ਸਾਡੇ ਅਨੁਭਵ ਬਾਰੇ ਗੱਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ।

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

ਅਣੂ

ਅਣੂ - ਜਵਾਬਦੇਹ ਭੂਮਿਕਾਵਾਂ ਦੀ ਜਾਂਚ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਇੱਕ ਢਾਂਚਾ।

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

ਹੁਣ ਹੋਰ.

ਥਿਊਰੀ ਦਾ ਕੁਝ ਹਿੱਸਾ

ਆਉ ਅਸੀਂ ਅਣੂ ਦੀਆਂ ਦੋ ਮੁੱਖ ਇਕਾਈਆਂ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ: ਦ੍ਰਿਸ਼ ਅਤੇ ਡ੍ਰਾਈਵਰ।

ਦ੍ਰਿਸ਼ਟੀਕੋਣ

ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੀ, ਕਿੱਥੇ, ਕਿਵੇਂ ਅਤੇ ਕਿਸ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ ਜਾਵੇਗਾ ਇਸਦਾ ਵਰਣਨ ਸ਼ਾਮਲ ਹੈ। ਇੱਕ ਰੋਲ ਵਿੱਚ ਕਈ ਸਕ੍ਰਿਪਟਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ ਹਰ ਇੱਕ ਮਾਰਗ ਦੇ ਨਾਲ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਹੈ <role>/molecule/<scenario>, ਟੈਸਟ ਲਈ ਲੋੜੀਂਦੀਆਂ ਕਾਰਵਾਈਆਂ ਦਾ ਵੇਰਵਾ ਰੱਖਦਾ ਹੈ। ਇੱਕ ਸਕ੍ਰਿਪਟ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ default, ਜੋ ਕਿ ਆਟੋਮੈਟਿਕਲੀ ਬਣ ਜਾਵੇਗੀ ਜੇਕਰ ਤੁਸੀਂ Molecule ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਭੂਮਿਕਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ। ਹੇਠ ਲਿਖੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਨਾਮ ਤੁਹਾਡੀ ਮਰਜ਼ੀ ਅਨੁਸਾਰ ਹਨ।

ਇੱਕ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਜਾਂਚ ਕਿਰਿਆਵਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਮੈਟਰਿਕਸ, ਅਤੇ ਮੂਲ ਰੂਪ ਵਿੱਚ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਹੈ:

(ਕਦਮਾਂ ਦੀ ਨਿਸ਼ਾਨਦੇਹੀ ਕੀਤੀ ਗਈ ?, ਮੂਲ ਰੂਪ ਵਿੱਚ ਛੱਡੇ ਜਾਂਦੇ ਹਨ ਜੇਕਰ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ)

• lint - ਚੱਲ ਰਹੇ ਲਿੰਟਰ। ਮੂਲ ਰੂਪ ਵਿੱਚ yamllint и flake8,
• destroy - ਅਣੂ ਦੇ ਆਖਰੀ ਲਾਂਚ ਤੋਂ ਉਦਾਹਰਨਾਂ ਨੂੰ ਮਿਟਾਉਣਾ (ਜੇ ਕੋਈ ਬਚਿਆ ਹੈ),
• dependency? - ਟੈਸਟ ਕੀਤੀ ਭੂਮਿਕਾ ਦੀ ਜਵਾਬਦੇਹ ਨਿਰਭਰਤਾ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ,
• syntax - ਵਰਤ ਕੇ ਭੂਮਿਕਾ ਸੰਟੈਕਸ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ ansible-playbook --syntax-check,
• create - ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਣਾ,
• prepare? - ਉਦਾਹਰਣ ਦੀ ਤਿਆਰੀ; ਉਦਾਹਰਨ ਲਈ python2 ਦੀ ਜਾਂਚ/ਇੰਸਟਾਲ ਕਰਨਾ
• converge - ਟੈਸਟ ਕੀਤੀ ਪਲੇਬੁੱਕ ਨੂੰ ਲਾਂਚ ਕਰਨਾ,
• idempotence - ਇਮਪੋਟੈਂਸੀ ਟੈਸਟ ਲਈ ਪਲੇਬੁੱਕ ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਓ,
• side_effect? - ਕਾਰਵਾਈਆਂ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਭੂਮਿਕਾ ਨਾਲ ਸਬੰਧਤ ਨਹੀਂ ਹਨ, ਪਰ ਟੈਸਟਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹਨ,
• verify — ਵਰਤਦੇ ਹੋਏ ਨਤੀਜੇ ਵਜੋਂ ਸੰਰਚਨਾ ਦੇ ਚੱਲ ਰਹੇ ਟੈਸਟ testinfra(ਮੂਲ) /goss/inspec,
• cleanup? - (ਨਵੇਂ ਸੰਸਕਰਣਾਂ ਵਿੱਚ) - ਮੋਟੇ ਤੌਰ 'ਤੇ, ਅਣੂ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਬਾਹਰੀ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ "ਸਫ਼ਾਈ" ਕਰਨਾ,
• destroy - ਇੱਕ ਉਦਾਹਰਣ ਨੂੰ ਮਿਟਾਉਣਾ.

ਇਹ ਕ੍ਰਮ ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ, ਪਰ ਜੇ ਲੋੜ ਹੋਵੇ ਤਾਂ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਉਪਰੋਕਤ ਕਦਮਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ molecule <command>. ਪਰ ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਹਰੇਕ ਅਜਿਹੇ cli ਕਮਾਂਡ ਲਈ ਕਿਰਿਆਵਾਂ ਦਾ ਆਪਣਾ ਕ੍ਰਮ ਹੋ ਸਕਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਚਲਾ ਕੇ ਲੱਭ ਸਕਦੇ ਹੋ। molecule matrix <command>. ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਕਮਾਂਡ ਚਲਾਉਂਦੇ ਹੋ converge (ਟੈਸਟ ਕੀਤੀ ਪਲੇਬੁੱਕ ਨੂੰ ਚਲਾਉਣਾ) ਹੇਠ ਲਿਖੀਆਂ ਕਾਰਵਾਈਆਂ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ:

$ molecule matrix converge
...
└── default         # название сценария
    ├── dependency  # установка зависимостей
    ├── create      # создание инстанса
    ├── prepare     # преднастройка инстанса
    └── converge    # прогон плейбука

ਇਹਨਾਂ ਕਾਰਵਾਈਆਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੰਪਾਦਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਜੇਕਰ ਸੂਚੀ ਵਿੱਚੋਂ ਕੁਝ ਪਹਿਲਾਂ ਹੀ ਪੂਰਾ ਹੋ ਗਿਆ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇਗਾ। ਮੌਜੂਦਾ ਸਥਿਤੀ, ਅਤੇ ਨਾਲ ਹੀ ਉਦਾਹਰਨ ਸੰਰਚਨਾ, ਅਣੂ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ $TMPDIR/molecule/<role>/<scenario>.

ਨਾਲ ਕਦਮ ਜੋੜੋ ? ਤੁਸੀਂ ਜਵਾਬੀ ਪਲੇਬੁੱਕ ਫਾਰਮੈਟ ਵਿੱਚ ਲੋੜੀਂਦੀਆਂ ਕਾਰਵਾਈਆਂ ਦਾ ਵਰਣਨ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਕਦਮ ਦੇ ਅਨੁਸਾਰ ਫਾਈਲ ਨਾਮ ਬਣਾ ਸਕਦੇ ਹੋ: prepare.yml/side_effect.yml. ਇਹ ਅਣੂ ਫਾਈਲਾਂ ਸਕ੍ਰਿਪਟ ਫੋਲਡਰ ਵਿੱਚ ਹੋਣ ਦੀ ਉਮੀਦ ਕਰੋ।

ਡਰਾਈਵਰ

ਇੱਕ ਡ੍ਰਾਈਵਰ ਇੱਕ ਅਜਿਹੀ ਹਸਤੀ ਹੈ ਜਿੱਥੇ ਟੈਸਟਾਂ ਲਈ ਉਦਾਹਰਣਾਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ।
ਸਟੈਂਡਰਡ ਡ੍ਰਾਈਵਰਾਂ ਦੀ ਸੂਚੀ ਜਿਸ ਲਈ ਅਣੂ ਕੋਲ ਤਿਆਰ ਟੈਂਪਲੇਟ ਹਨ: Azure, Docker, EC2, GCE, LXC, LXD, OpenStack, Vagrant, Delegated.

ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਟੈਂਪਲੇਟ ਫਾਈਲਾਂ ਹੁੰਦੀਆਂ ਹਨ create.yml и destroy.yml ਸਕ੍ਰਿਪਟ ਫੋਲਡਰ ਵਿੱਚ, ਜੋ ਕ੍ਰਮਵਾਰ, ਉਦਾਹਰਨ ਦੀ ਰਚਨਾ ਅਤੇ ਮਿਟਾਉਣ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ।
ਅਪਵਾਦ ਹਨ ਡੌਕਰ ਅਤੇ ਵੈਗਰੈਂਟ, ਕਿਉਂਕਿ ਉਹਨਾਂ ਦੇ ਮੋਡੀਊਲਾਂ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਉਪਰੋਕਤ ਫਾਈਲਾਂ ਤੋਂ ਬਿਨਾਂ ਹੋ ਸਕਦਾ ਹੈ।

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

ਡਿਫਾਲਟ ਡਰਾਈਵਰ ਡੌਕਰ ਹੈ।

ਹੁਣ ਅਭਿਆਸ ਵੱਲ ਵਧਦੇ ਹਾਂ ਅਤੇ ਉੱਥੇ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਦੇ ਹਾਂ।

ਸ਼ੁਰੂਆਤ

ਇੱਕ "ਹੈਲੋ ਵਰਲਡ" ਵਜੋਂ ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ nginx ਇੰਸਟਾਲੇਸ਼ਨ ਰੋਲ ਦੀ ਜਾਂਚ ਕਰਾਂਗੇ। ਚਲੋ ਡਰਾਇਵਰ ਵਜੋਂ ਡੌਕਰ ਦੀ ਚੋਣ ਕਰੀਏ - ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਵਿੱਚੋਂ ਬਹੁਤਿਆਂ ਨੇ ਇਸਨੂੰ ਸਥਾਪਿਤ ਕੀਤਾ ਹੈ (ਅਤੇ ਯਾਦ ਰੱਖੋ ਕਿ ਡੌਕਰ ਡਿਫੌਲਟ ਡਰਾਈਵਰ ਹੈ)।

ਤਿਆਰ ਕਰੋ virtualenv ਅਤੇ ਇਸ ਵਿੱਚ ਇਸ ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ molecule:

> pip install virtualenv
> virtualenv -p `which python2` venv
> source venv/bin/activate
> pip install molecule docker  # molecule установит ansible как зависимость; docker для драйвера

ਅਗਲਾ ਕਦਮ ਇੱਕ ਨਵੀਂ ਭੂਮਿਕਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ।
ਇੱਕ ਨਵੀਂ ਭੂਮਿਕਾ ਦੀ ਸ਼ੁਰੂਆਤ, ਅਤੇ ਨਾਲ ਹੀ ਇੱਕ ਨਵੀਂ ਸਕ੍ਰਿਪਟ, ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ molecule init <params>:

> molecule init role -r nginx
--> Initializing new role nginx...
Initialized role in <path>/nginx successfully.
> cd nginx
> tree -L 1
.
├── README.md
├── defaults
├── handlers
├── meta
├── molecule
├── tasks
└── vars

6 directories, 1 file

ਨਤੀਜਾ ਇੱਕ ਆਮ ਜਵਾਬਦੇਹ ਭੂਮਿਕਾ ਹੈ. ਅੱਗੇ, ਅਣੂ CLI ਨਾਲ ਸਾਰੀਆਂ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਰੋਲ ਰੂਟ ਤੋਂ ਬਣੀਆਂ ਹਨ।

ਆਓ ਦੇਖੀਏ ਕਿ ਰੋਲ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਕੀ ਹੈ:

> tree molecule/default/
molecule/default/
├── Dockerfile.j2  # Jinja-шаблон для Dockerfile
├── INSTALL.rst.   # Немного информации об установке зависимостей сценария
├── molecule.yml   # Файл конфигурации
├── playbook.yml   # Плейбук запуска роли
└── tests          # Директория с тестами стадии verify
    └── test_default.py

1 directory, 6 files

ਆਉ ਸੰਰਚਨਾ ਨੂੰ ਵੇਖੀਏ molecule/default/molecule.yml (ਅਸੀਂ ਸਿਰਫ ਡੌਕਰ ਚਿੱਤਰ ਨੂੰ ਬਦਲਾਂਗੇ):

---
dependency:
  name: galaxy
driver:
  name: docker
lint:
  name: yamllint
platforms:
  - name: instance
    image: centos:7
provisioner:
  name: ansible
  lint:
    name: ansible-lint
scenario:
  name: default
verifier:
  name: testinfra
  lint:
    name: flake8

ਨਿਰਭਰਤਾ

ਇਹ ਭਾਗ ਨਿਰਭਰਤਾ ਦੇ ਸਰੋਤ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ।

ਸੰਭਵ ਵਿਕਲਪ: ਗਲੈਕਸੀ, ਗਿਲਟ, ਸ਼ੈੱਲ.

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

ਮੈਂ ਇੱਥੇ ਜ਼ਿਆਦਾ ਦੇਰ ਤੱਕ ਨਹੀਂ ਰਹਾਂਗਾ, ਇਸ ਵਿੱਚ ਕਾਫ਼ੀ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ ਦਸਤਾਵੇਜ਼.

ਡਰਾਈਵਰ

ਡਰਾਈਵਰ ਦਾ ਨਾਮ। ਸਾਡੇ ਲਈ ਇਹ ਡੌਕਰ ਹੈ.

lint

ਯਮਲਿਨਟ ਦੀ ਵਰਤੋਂ ਲਿੰਟਰ ਵਜੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਸੰਰਚਨਾ ਦੇ ਇਸ ਹਿੱਸੇ ਵਿੱਚ ਉਪਯੋਗੀ ਵਿਕਲਪ yamllint, ਫਾਰਵਰਡ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ, ਜਾਂ linter ਨੂੰ ਅਯੋਗ ਕਰਨ ਲਈ ਇੱਕ ਸੰਰਚਨਾ ਫਾਇਲ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨ ਦੀ ਯੋਗਤਾ ਹਨ:

lint:
  name: yamllint
  options:
    config-file: foo/bar
  env:
    FOO: bar
  enabled: False

ਪਲੇਟਫਾਰਮ

ਉਦਾਹਰਨਾਂ ਦੀ ਸੰਰਚਨਾ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ।
ਇੱਕ ਡਰਾਈਵਰ ਦੇ ਤੌਰ ਤੇ ਡੌਕਰ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਅਣੂ ਇਸ ਭਾਗ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਅਤੇ ਸੂਚੀ ਦਾ ਹਰੇਕ ਤੱਤ ਇਸ ਵਿੱਚ ਉਪਲਬਧ ਹੈ Dockerfile.j2 ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਰੂਪ ਵਿੱਚ item.

ਜਿਸ ਵਿਚ ਡਰਾਈਵਰ ਦੇ ਮਾਮਲੇ ਵਿਚ ਸੀ create.yml и destroy.yml, ਸੈਕਸ਼ਨ ਉਹਨਾਂ ਵਿੱਚ ਉਪਲਬਧ ਹੈ molecule_yml.platforms, ਅਤੇ ਇਸ ਉੱਤੇ ਦੁਹਰਾਓ ਪਹਿਲਾਂ ਹੀ ਇਹਨਾਂ ਫਾਈਲਾਂ ਵਿੱਚ ਵਰਣਿਤ ਹਨ।

ਕਿਉਂਕਿ Molecule Ansible ਮੌਡਿਊਲਾਂ ਨੂੰ ਉਦਾਹਰਨ ਪ੍ਰਬੰਧਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਤੁਹਾਨੂੰ ਉੱਥੇ ਸੰਭਵ ਸੈਟਿੰਗਾਂ ਦੀ ਸੂਚੀ ਲੱਭਣੀ ਚਾਹੀਦੀ ਹੈ। ਡੌਕਰ ਲਈ, ਉਦਾਹਰਨ ਲਈ, ਮੋਡੀਊਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ docker_container_module. ਹੋਰ ਡਰਾਈਵਰਾਂ ਵਿੱਚ ਕਿਹੜੇ ਮੋਡੀਊਲ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਦਸਤਾਵੇਜ਼.

ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਡਰਾਈਵਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਵੀ ਲੱਭ ਸਕਦੇ ਹੋ ਅਣੂ ਦੇ ਟੈਸਟਾਂ ਵਿੱਚ.

ਆਓ ਇੱਥੇ ਬਦਲੀਏ centos:7 'ਤੇ ਉਬਤੂੰ.

ਪ੍ਰੋਵੀਜ਼ਨਰ

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

• ਪਲੇਬੁੱਕ: ਤੁਸੀਂ ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਿਹੜੀਆਂ ਪਲੇਬੁੱਕਾਂ ਨੂੰ ਕੁਝ ਪੜਾਵਾਂ 'ਤੇ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

provisioner:
  name: ansible
  playbooks:
    create: create.yml
    destroy: ../default/destroy.yml
    converge: playbook.yml
    side_effect: side_effect.yml
    cleanup: cleanup.yml

• config_options: ਜਵਾਬਦੇਹ ਸੰਰਚਨਾ

provisioner:
  name: ansible
  config_options:
    defaults:
      fact_caching: jsonfile
    ssh_connection:
      scp_if_ssh: True

• connect_options: ਵਿਕਲਪ ਕੁਨੈਕਟੀਵਿਟੀ

provisioner:
  name: ansible  
  connection_options:
    ansible_ssh_common_args: "-o 'UserKnownHostsFile=/dev/null' -o 'ForwardAgent=yes'"

• ਚੋਣ: ਜਵਾਬਦੇਹ ਮਾਪਦੰਡ ਅਤੇ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ

provisioner:
  name: ansible  
  options:
    vvv: true
    diff: true
  env:
    FOO: BAR

ਦ੍ਰਿਸ਼

ਸਕ੍ਰਿਪਟ ਕ੍ਰਮ ਦਾ ਸਿਰਲੇਖ ਅਤੇ ਵਰਣਨ।
ਤੁਸੀਂ ਕੁੰਜੀ ਜੋੜ ਕੇ ਕਮਾਂਡ ਦੇ ਡਿਫਾਲਟ ਐਕਸ਼ਨ ਮੈਟਰਿਕਸ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ <command>_sequence ਅਤੇ ਇਸਦੇ ਲਈ ਇੱਕ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ, ਸਾਨੂੰ ਲੋੜੀਂਦੇ ਕਦਮਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ।
ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ ਪਲੇਬੁੱਕ ਰਨ ਕਮਾਂਡ ਚਲਾਉਣ ਵੇਲੇ ਕਿਰਿਆਵਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹਾਂ: molecule converge

# изначально:
# - dependency
# - create
# - prepare
# - converge
scenario:
  name: default
  converge_sequence:
    - create
    - converge

ਚੈੱਕ

ਟੈਸਟਾਂ ਲਈ ਇੱਕ ਢਾਂਚਾ ਸਥਾਪਤ ਕਰਨਾ ਅਤੇ ਇਸਦੇ ਲਈ ਇੱਕ ਲਿੰਟਰ. ਮੂਲ ਰੂਪ ਵਿੱਚ, ਲਿੰਟਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ testinfra и flake8. ਸੰਭਵ ਵਿਕਲਪ ਉਪਰੋਕਤ ਦੇ ਸਮਾਨ ਹਨ:

verifier:
  name: testinfra
  additional_files_or_dirs:
    - ../path/to/test_1.py
    - ../path/to/test_2.py
    - ../path/to/directory/*
  options:
    n: 1
  enabled: False
  env:
    FOO: bar
  lint:
    name: flake8
    options:
      benchmark: True
    enabled: False
    env:
      FOO: bar

ਚਲੋ ਆਪਣੀ ਭੂਮਿਕਾ ਵੱਲ ਮੁੜਦੇ ਹਾਂ। ਚਲੋ ਫਾਈਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰੀਏ tasks/main.yml ਇਸ ਦਿੱਖ ਲਈ:

---
- name: Install nginx
  apt:
    name: nginx
    state: present

- name: Start nginx
  service:
    name: nginx
    state: started

ਅਤੇ ਇਸ ਵਿੱਚ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ molecule/default/tests/test_default.py

def test_nginx_is_installed(host):
    nginx = host.package("nginx")
    assert nginx.is_installed

def test_nginx_running_and_enabled(host):
    nginx = host.service("nginx")
    assert nginx.is_running
    assert nginx.is_enabled

def test_nginx_config(host):
    host.run("nginx -t")

ਹੋ ਗਿਆ, ਸਭ ਕੁਝ ਚੱਲਣਾ ਬਾਕੀ ਹੈ (ਭੂਮਿਕਾ ਦੀ ਜੜ੍ਹ ਤੋਂ, ਮੈਨੂੰ ਤੁਹਾਨੂੰ ਯਾਦ ਦਿਵਾਉਣ ਦਿਓ):

> molecule test

ਵਿਗਾੜਨ ਦੇ ਅਧੀਨ ਲੰਬਾ ਨਿਕਾਸ:

--> Validating schema <path>/nginx/molecule/default/molecule.yml.
Validation completed successfully.
--> Test matrix

└── default
    ├── lint
    ├── destroy
    ├── dependency
    ├── syntax
    ├── create
    ├── prepare
    ├── converge
    ├── idempotence
    ├── side_effect
    ├── verify
    └── destroy

--> Scenario: 'default'
--> Action: 'lint'
--> Executing Yamllint on files found in <path>/nginx/...
Lint completed successfully.
--> Executing Flake8 on files found in <path>/nginx/molecule/default/tests/...
Lint completed successfully.
--> Executing Ansible Lint on <path>/nginx/molecule/default/playbook.yml...
Lint completed successfully.
--> Scenario: 'default'
--> Action: 'destroy'

    PLAY [Destroy] *****************************************************************

    TASK [Destroy molecule instance(s)] ********************************************
    changed: [localhost] => (item=None)
    changed: [localhost]

    TASK [Wait for instance(s) deletion to complete] *******************************
    ok: [localhost] => (item=None)
    ok: [localhost]

    TASK [Delete docker network(s)] ************************************************

    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0

--> Scenario: 'default'
--> Action: 'dependency'
Skipping, missing the requirements file.
--> Scenario: 'default'
--> Action: 'syntax'

    playbook: <path>/nginx/molecule/default/playbook.yml

--> Scenario: 'default'
--> Action: 'create'

    PLAY [Create] ******************************************************************

    TASK [Log into a Docker registry] **********************************************
    skipping: [localhost] => (item=None)

    TASK [Create Dockerfiles from image names] *************************************
    changed: [localhost] => (item=None)
    changed: [localhost]

    TASK [Discover local Docker images] ********************************************
    ok: [localhost] => (item=None)
    ok: [localhost]

    TASK [Build an Ansible compatible image] ***************************************
    changed: [localhost] => (item=None)
    changed: [localhost]

    TASK [Create docker network(s)] ************************************************

    TASK [Create molecule instance(s)] *********************************************
    changed: [localhost] => (item=None)
    changed: [localhost]

    TASK [Wait for instance(s) creation to complete] *******************************
    changed: [localhost] => (item=None)
    changed: [localhost]

    PLAY RECAP *********************************************************************
    localhost                  : ok=5    changed=4    unreachable=0    failed=0

--> Scenario: 'default'
--> Action: 'prepare'
Skipping, prepare playbook not configured.
--> Scenario: 'default'
--> Action: 'converge'

    PLAY [Converge] ****************************************************************

    TASK [Gathering Facts] *********************************************************
    ok: [instance]

    TASK [nginx : Install nginx] ***************************************************
    changed: [instance]

    TASK [nginx : Start nginx] *****************************************************
    changed: [instance]

    PLAY RECAP *********************************************************************
    instance                   : ok=3    changed=2    unreachable=0    failed=0

--> Scenario: 'default'
--> Action: 'idempotence'
Idempotence completed successfully.
--> Scenario: 'default'
--> Action: 'side_effect'
Skipping, side effect playbook not configured.
--> Scenario: 'default'
--> Action: 'verify'
--> Executing Testinfra tests found in <path>/nginx/molecule/default/tests/...
    ============================= test session starts ==============================
    platform darwin -- Python 2.7.15, pytest-4.3.0, py-1.8.0, pluggy-0.9.0
    rootdir: <path>/nginx/molecule/default, inifile:
    plugins: testinfra-1.16.0
collected 4 items

    tests/test_default.py ....                                               [100%]

    ========================== 4 passed in 27.23 seconds ===========================
Verifier completed successfully.
--> Scenario: 'default'
--> Action: 'destroy'

    PLAY [Destroy] *****************************************************************

    TASK [Destroy molecule instance(s)] ********************************************
    changed: [localhost] => (item=None)
    changed: [localhost]

    TASK [Wait for instance(s) deletion to complete] *******************************
    changed: [localhost] => (item=None)
    changed: [localhost]

    TASK [Delete docker network(s)] ************************************************

    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=2    unreachable=0    failed=0

ਸਾਡੀ ਸਧਾਰਨ ਭੂਮਿਕਾ ਬਿਨਾਂ ਕਿਸੇ ਸਮੱਸਿਆ ਦੇ ਟੈਸਟ ਕੀਤੀ ਗਈ।
ਇਹ ਯਾਦ ਰੱਖਣ ਯੋਗ ਹੈ ਕਿ ਜੇ ਓਪਰੇਸ਼ਨ ਦੌਰਾਨ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ molecule test, ਫਿਰ ਜੇਕਰ ਤੁਸੀਂ ਮਿਆਰੀ ਕ੍ਰਮ ਨੂੰ ਨਹੀਂ ਬਦਲਿਆ, ਤਾਂ Molecule ਉਦਾਹਰਨ ਨੂੰ ਮਿਟਾ ਦੇਵੇਗਾ।

ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਕਮਾਂਡਾਂ ਡੀਬੱਗਿੰਗ ਲਈ ਉਪਯੋਗੀ ਹਨ:

> molecule --debug <command> # debug info. При обычном запуске Молекула скрывает логи.
> molecule converge          # Оставляет инстанс после прогона тестируемой роли.
> molecule login             # Зайти в созданный инстанс.
> molecule --help            # Полный список команд.

ਮੌਜੂਦਾ ਭੂਮਿਕਾ

ਇੱਕ ਮੌਜੂਦਾ ਭੂਮਿਕਾ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਸਕ੍ਰਿਪਟ ਜੋੜਨਾ ਵਾਪਰਦਾ ਹੈ ਰੋਲ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡਾਂ ਨਾਲ:

# полный список доступных параметров
> molecule init scenarion --help
# создание нового сценария
> molecule init scenario -r <role_name> -s <scenario_name>

ਜੇ ਇਹ ਭੂਮਿਕਾ ਵਿੱਚ ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਹੈ, ਤਾਂ ਪੈਰਾਮੀਟਰ -s ਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇੱਕ ਸਕ੍ਰਿਪਟ ਬਣਾਈ ਜਾਵੇਗੀ default.

ਸਿੱਟਾ

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

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ. ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਜਵਾਬਦੇਹ ਭੂਮਿਕਾਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦਾ ਅਨੁਭਵ ਹੈ, ਅਤੇ ਇਹ ਅਣੂ ਨਾਲ ਸਬੰਧਤ ਨਹੀਂ ਹੈ, ਤਾਂ ਸਾਨੂੰ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਇਸ ਬਾਰੇ ਦੱਸੋ!

ਸਰੋਤ: www.habr.com