Table of Contents

ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ Ansible: 2026 ਵਿੱਚ IT ਆਟੋਮੇਸ਼ਨ ਦੀ ਪੂਰੀ ਗਾਈਡ

Ansible ਉਦਯੋਗ ਦੇ ਅਗੇਤੂ ਆਟੋਮੇਸ਼ਨ ਪਲੇਟਫਾਰਮ ਵਜੋਂ ਵਿਕਸਿਤ ਹੋਇਆ ਹੈ। ਸਰੋਤ ਅਨੁਸਾਰ, Fortune 500 ਦੀਆਂ 80% ਤੋਂ ਵੱਧ ਕੰਪਨੀਆਂ ਜਟਿਲ IT ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ Ansible ਵਰਤਦੀਆਂ ਹਨ। 2026 ਵਿੱਚ ਵੀ ਇਹ ਸੌਖੀ ਵਰਤੋਂ ਅਤੇ ਐਂਟਰਪ੍ਰਾਈਜ਼ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਾਲਾ ਮਹੱਤਵਪੂਰਨ ਹੱਲ ਹੈ।

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

Ansible ਕੀ ਹੈ? ਬੁਨਿਆਦੀ ਗੱਲਾਂ ਸਮਝੋ

Ansible ਇੱਕ ਓਪਨ-ਸੋਰਸ ਆਟੋਮੇਸ਼ਨ ਪਲੇਟਫਾਰਮ ਹੈ, ਜੋ ਏਜੰਟ-ਰਹਿਤ ਘੋਸ਼ਣਾਤਮਕ ਆਟੋਮੇਸ਼ਨ ਰਾਹੀਂ IT ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਦਾ ਪ੍ਰਬੰਧਨ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ। ਰਵਾਇਤੀ ਕੌਂਫਿਗਰੇਸ਼ਨ ਪ੍ਰਬੰਧਨ ਟੂਲਾਂ ਤੋਂ ਵੱਖ, ਇਸਨੂੰ ਪ੍ਰਬੰਧਿਤ ਨੋਡਾਂ ਉੱਤੇ ਏਜੰਟ ਲਗਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ। ਇਹ ਦੂਰੋਂ ਪ੍ਰਬੰਧਨ ਲਈ Linux ਅਤੇ Unix ਉੱਤੇ SSH, ਅਤੇ Windows ਉੱਤੇ WinRM ਵਰਤਦਾ ਹੈ।

Ansible ਦੀਆਂ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

1. ਏਜੰਟ-ਰਹਿਤ ਆਰਕੀਟੈਕਚਰ:

  • ਪ੍ਰਬੰਧਿਤ ਨੋਡਾਂ ਉੱਤੇ ਸਾਫਟਵੇਅਰ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ
  • ਮੌਜੂਦਾ SSH ਜਾਂ WinRM ਪ੍ਰੋਟੋਕੋਲ ਵਰਤਦਾ ਹੈ
  • ਹਮਲੇ ਦੀ ਸਤਹ ਅਤੇ ਸੰਭਾਲ ਦਾ ਕੰਮ ਘਟਾਉਂਦਾ ਹੈ
  • ਏਜੰਟ-ਅਧਾਰਿਤ ਟੂਲਾਂ ਨਾਲੋਂ ਸ਼ੁਰੂ ਕਰਨਾ ਸੌਖਾ ਹੈ

2. ਘੋਸ਼ਣਾਤਮਕ ਭਾਸ਼ਾ (YAML):

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

3. ਪੁਸ਼ ਮਾਡਲ:

  • ਕੰਟਰੋਲ ਨੋਡ ਪ੍ਰਬੰਧਿਤ ਨੋਡਾਂ ਨੂੰ ਕੌਂਫਿਗਰੇਸ਼ਨ ਭੇਜਦਾ ਹੈ
  • ਏਜੰਟਾਂ ਦੀ ਉਡੀਕ ਬਿਨਾਂ ਕੰਮ ਤੁਰੰਤ ਚਲਾਉਂਦਾ ਹੈ
  • ਕੇਂਦਰੀਕ੍ਰਿਤ ਕੰਟਰੋਲ ਅਤੇ ਦਿੱਖ
  • ਮੰਗ ਅਨੁਸਾਰ ਆਟੋਮੇਸ਼ਨ ਲਈ ਢੁੱਕਵਾਂ

4. ਵੱਡੀ ਮੋਡੀਊਲ ਲਾਇਬ੍ਰੇਰੀ:

  • 5,000 ਤੋਂ ਵੱਧ ਬਿਲਟ-ਇਨ ਮੋਡੀਊਲ (2026 ਤੱਕ)
  • Linux, Windows, ਨੈੱਟਵਰਕ ਡਿਵਾਈਸਾਂ ਅਤੇ ਕਲਾਉਡ ਪਲੇਟਫਾਰਮਾਂ ਦਾ ਸਮਰਥਨ
  • ਕਮਿਊਨਿਟੀ ਅਤੇ ਵਿਕਰੇਤਾਵਾਂ ਦੇ ਮੋਡੀਊਲ
  • Python ਵਿੱਚ ਆਪਣੇ ਮੋਡੀਊਲ ਲਿਖਣੇ ਸੌਖੇ ਹਨ

Ansible ਕਿਹੜੇ ਕੰਮ ਆਟੋਮੇਟ ਕਰ ਸਕਦਾ ਹੈ?

Ansible ਇਨ੍ਹਾਂ ਕੰਮਾਂ ਦੇ ਆਟੋਮੇਸ਼ਨ ਲਈ ਢੁੱਕਵਾਂ ਹੈ:

  • ਕੌਂਫਿਗਰੇਸ਼ਨ ਪ੍ਰਬੰਧਨ: ਸਰਵਰਾਂ ਦੀਆਂ ਕੌਂਫਿਗਰੇਸ਼ਨਾਂ ਇਕਸਾਰ ਰੱਖਣਾ
  • ਐਪਲੀਕੇਸ਼ਨ ਡਿਪਲੌਇਮੈਂਟ: ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਲਗਾਉਣਾ
  • ਪ੍ਰੋਵਿਜ਼ਨਿੰਗ: ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਬਣਾਉਣਾ ਅਤੇ ਕੌਂਫਿਗਰ ਕਰਨਾ
  • ਨਿਰੰਤਰ ਡਿਲਿਵਰੀ: CI/CD ਪਾਈਪਲਾਈਨਾਂ ਨਾਲ ਜੋੜਨਾ
  • ਸੁਰੱਖਿਆ ਅਤੇ ਪਾਲਣਾ: ਸੁਰੱਖਿਆ ਨੀਤੀਆਂ ਅਤੇ ਪਾਲਣਾ ਲਾਗੂ ਕਰਨਾ
  • ਆਰਕੇਸਟ੍ਰੇਸ਼ਨ: ਜਟਿਲ ਬਹੁ-ਪੱਧਰੀ ਡਿਪਲੌਇਮੈਂਟ ਦਾ ਤਾਲਮੇਲ
  • ਕਲਾਉਡ ਆਟੋਮੇਸ਼ਨ: AWS, Azure, GCP ਅਤੇ ਹੋਰ ਕਲਾਉਡਾਂ ਦਾ ਪ੍ਰਬੰਧਨ
  • ਨੈੱਟਵਰਕ ਆਟੋਮੇਸ਼ਨ: ਸਵਿੱਚਾਂ, ਰਾਊਟਰਾਂ ਅਤੇ ਫਾਇਰਵਾਲਾਂ ਦੀ ਕੌਂਫਿਗਰੇਸ਼ਨ
  • Windows ਆਟੋਮੇਸ਼ਨ: Windows ਸਰਵਰਾਂ ਅਤੇ ਵਰਕਸਟੇਸ਼ਨਾਂ ਦਾ ਪ੍ਰਬੰਧਨ

Ansible ਦਾ ਵਿਕਾਸ: 2012 ਤੋਂ 2026

ਸਮਾਂ-ਰੇਖਾ:

  • 2012: Michael DeHaan ਨੇ Ansible ਬਣਾਇਆ
  • 2015: Red Hat ਨੇ Ansible ਖਰੀਦਿਆ
  • 2019: Ansible Engine 2.8 ਨੇ ਕਲੈਕਸ਼ਨ ਪੇਸ਼ ਕੀਤੇ
  • 2020: Ansible 2.10+ ਨੂੰ ansible-core ਅਤੇ ਕਲੈਕਸ਼ਨਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ
  • 2023: Ansible 8.x ਨੇ ਕਲਾਉਡ ਇੰਟੀਗ੍ਰੇਸ਼ਨਾਂ ਵਧਾਈਆਂ
  • 2026: Ansible 10.x ਵਿੱਚ AI-ਸਹਾਇਤਾ ਨਾਲ ਪਲੇਬੁੱਕ ਬਣਾਉਣਾ, Windows ਦਾ ਬਿਹਤਰ ਸਮਰਥਨ ਅਤੇ ਵਧੀਆਂ ਸੁਰੱਖਿਆ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ

Ansible ਅਤੇ ਮੁਕਾਬਲੇ ਦੇ ਟੂਲਾਂ ਦੀ ਤੇਜ਼ ਤੁਲਨਾ

ਵਿਸ਼ੇਸ਼ਤਾAnsibleTerraformPuppetChef
ਕਿਸਮਕੌਂਫਿਗਰੇਸ਼ਨ ਪ੍ਰਬੰਧਨਇਨਫਰਾਸਟ੍ਰਕਚਰ ਪ੍ਰੋਵਿਜ਼ਨਿੰਗਕੌਂਫਿਗਰੇਸ਼ਨ ਪ੍ਰਬੰਧਨਕੌਂਫਿਗਰੇਸ਼ਨ ਪ੍ਰਬੰਧਨ
ਭਾਸ਼ਾYAMLHCLPuppet DSL (Ruby ਵਰਗੀ)Ruby DSL
ਏਜੰਟ ਲੋੜੀਂਦਾਨਹੀਂਨਹੀਂਹਾਂਹਾਂ
ਸਿੱਖਣ ਦੀ ਔਖਿਆਈਸੌਖੀਦਰਮਿਆਨੀਔਖੀਔਖੀ
ਵਧੀਆ ਵਰਤੋਂਕੌਂਫਿਗਰੇਸ਼ਨ ਪ੍ਰਬੰਧਨ, ਡਿਪਲੌਇਮੈਂਟਕਲਾਉਡ ਇਨਫਰਾਸਟ੍ਰਕਚਰਵੱਡੇ ਉਦਯੋਗਜਟਿਲ ਵਰਕਫਲੋ
ਸਥਿਤੀ ਪ੍ਰਬੰਧਨਪੁਸ਼ ਮਾਡਲਘੋਸ਼ਣਾਤਮਕ ਸਥਿਤੀ ਫਾਈਲਪੁਲ ਮਾਡਲਪੁਲ ਮਾਡਲ
Windows ਸਮਰਥਨਸ਼ਾਨਦਾਰ (2026)ਸੀਮਿਤਚੰਗਾਚੰਗਾ
ਕਮਿਊਨਿਟੀ ਦਾ ਆਕਾਰਬਹੁਤ ਵੱਡਾਬਹੁਤ ਵੱਡਾਵੱਡਾਦਰਮਿਆਨਾ
ਮੁੱਖ ਵਰਤੋਂਰੋਜ਼ਾਨਾ ਕਾਰਵਾਈਆਂਇਨਫਰਾਸਟ੍ਰਕਚਰ ਪ੍ਰੋਵਿਜ਼ਨਿੰਗਐਂਟਰਪ੍ਰਾਈਜ਼ ਕੌਂਫਿਗਰੇਸ਼ਨਐਪਲੀਕੇਸ਼ਨ ਡਿਪਲੌਇਮੈਂਟ

Ansible ਕਦੋਂ ਚੁਣੋ:

  • ✅ ਹਾਈਬ੍ਰਿਡ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਕੌਂਫਿਗਰੇਸ਼ਨ ਪ੍ਰਬੰਧਨ
  • ✅ ਐਪਲੀਕੇਸ਼ਨ ਡਿਪਲੌਇਮੈਂਟ ਆਟੋਮੇਟ ਕਰਨਾ
  • ✅ ਸਿੱਖਣ ਲਈ ਘੱਟ ਸਮਾਂ ਉਪਲਬਧ ਹੋਵੇ
  • ✅ ਏਜੰਟ-ਰਹਿਤ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਤਰਜੀਹ ਹੋਵੇ
  • ✅ ਮਜ਼ਬੂਤ Windows ਆਟੋਮੇਸ਼ਨ ਦੀ ਲੋੜ ਹੋਵੇ (2026 ਦੇ ਸੁਧਾਰ)
  • ✅ SSH ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਹੋਵੇ

ਵਿਕਲਪਾਂ ਉੱਤੇ ਕਦੋਂ ਵਿਚਾਰ ਕਰੋ:

  • Terraform: ਮੁੱਖ ਤੌਰ ਉੱਤੇ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਪ੍ਰੋਵਿਜ਼ਨਿੰਗ ਲਈ (AWS, Azure, GCP)
  • Puppet: ਹਜ਼ਾਰਾਂ ਨੋਡਾਂ ਵਾਲੇ ਵੱਡੇ ਉਦਯੋਗਾਂ ਲਈ
  • Chef: ਐਪਲੀਕੇਸ਼ਨ-ਕੇਂਦਰਿਤ ਜਟਿਲ ਵਰਕਫਲੋ ਲਈ

ਸ਼ੁਰੂਆਤ: 2026 ਵਿੱਚ Ansible ਇੰਸਟਾਲ ਕਰਨਾ

ਸਿਸਟਮ ਦੀਆਂ ਲੋੜਾਂ

ਕੰਟਰੋਲ ਨੋਡ, ਜਿੱਥੇ Ansible ਚੱਲਦਾ ਹੈ:

  • Linux, macOS ਜਾਂ Windows ਉੱਤੇ WSL2
  • Python 3.9 ਜਾਂ ਨਵਾਂ (2026 ਲਈ Python 3.11+ ਸਿਫ਼ਾਰਸ਼ੀ)
  • ਘੱਟੋ-ਘੱਟ 2 GB RAM, 4 GB ਜਾਂ ਵੱਧ ਸਿਫ਼ਾਰਸ਼ੀ
  • ਕਲੈਕਸ਼ਨਾਂ ਲਈ 5 GB ਡਿਸਕ ਥਾਂ

ਪ੍ਰਬੰਧਿਤ ਨੋਡ:

  • SSH ਪਹੁੰਚ (Linux/Unix) ਜਾਂ WinRM (Windows)
  • Python 2.7 ਜਾਂ Python 3.6+ (Linux)
  • PowerShell 5.1+ (Windows)
  • ਏਜੰਟ ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਲੋੜ ਨਹੀਂ

ਇੰਸਟਾਲੇਸ਼ਨ ਦੇ ਤਰੀਕੇ

ਤਰੀਕਾ 1: ਪੈਕੇਜ ਮੈਨੇਜਰ (ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਸਿਫ਼ਾਰਸ਼ੀ)

Ubuntu/Debian:

# ਨਵੇਂ ਵਰਜਨ ਲਈ Ansible PPA ਸ਼ਾਮਲ ਕਰੋ
sudo apt-add-repository ppa:ansible/ansible
sudo apt update
sudo apt install ansible -y

RHEL/CentOS/Rocky Linux:

# EPEL ਰਿਪੋਜ਼ਟਰੀ ਚਾਲੂ ਕਰੋ
sudo dnf install epel-release -y
sudo dnf install ansible -y

macOS:

# Homebrew ਵਰਤੋ
brew install ansible

ਤਰੀਕਾ 2: Python pip (ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ)

# pipx ਇੰਸਟਾਲ ਕਰੋ (ਸਿਫਾਰਸ਼ੀ ਅਲੱਗ ਵਾਤਾਵਰਣ)
python3 -m pip install --user pipx
python3 -m pipx ensurepath

# pipx ਨਾਲ Ansible ਇੰਸਟਾਲ ਕਰੋ
pipx install --include-deps ansible

# ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ
ansible --version

ਤਰੀਕਾ 3: Docker (ਪੋਰਟੇਬਲ)

# ਅਧਿਕਾਰਤ Ansible ਕੰਟੇਨਰ ਲਵੋ
docker pull quay.io/ansible/ansible:latest

# ਕੰਟੇਨਰ ਵਿੱਚ Ansible ਚਲਾਓ
docker run --rm -it quay.io/ansible/ansible:latest ansible --version

ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਜਾਂਚ

# Ansible ਵਰਜਨ ਚੈੱਕ ਕਰੋ
ansible --version

# ਉਮੀਦ ਕੀਤਾ ਆਉਟਪੁੱਟ (2026):
# ansible [core 2.16.5]
#   config file = /etc/ansible/ansible.cfg
#   python version = 3.11.8
#   jinja version = 3.1.3

ਸ਼ੁਰੂਆਤੀ ਕੌਂਫਿਗਰੇਸ਼ਨ

Ansible ਦੀ ਕੌਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲ ਬਣਾਓ:

# ਸੰਰਚਨਾ ਡਾਇਰੈਕਟਰੀ ਬਣਾਓ
mkdir -p ~/.ansible

# ansible.cfg ਬਣਾਓ
cat > ~/.ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ~/ansible/inventory
host_key_checking = False
retry_files_enabled = False
gathering = smart
fact_caching = jsonfile
fact_caching_connection = /tmp/ansible_facts
fact_caching_timeout = 3600

[privilege_escalation]
become = True
become_method = sudo
become_user = root
become_ask_pass = False
EOF

ਲਾਜ਼ਮੀ ਧਾਰਨਾਵਾਂ: Ansible ਦੇ ਹਿੱਸੇ

1. ਇਨਵੈਂਟਰੀ: ਆਪਣਾ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ

ਇਨਵੈਂਟਰੀ ਉਹਨਾਂ ਹੋਸਟਾਂ ਅਤੇ ਗਰੁੱਪਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਪ੍ਰਬੰਧਨ Ansible ਕਰਦਾ ਹੈ। ਇਹ ਸਥਿਰ (INI ਜਾਂ YAML ਫਾਈਲ) ਜਾਂ ਗਤੀਸ਼ੀਲ (ਸਕ੍ਰਿਪਟ ਜਾਂ ਪਲੱਗਇਨ) ਹੋ ਸਕਦੀ ਹੈ।

ਸਥਿਰ ਇਨਵੈਂਟਰੀ (INI ਫਾਰਮੈਟ)

# inventory/hosts.ini

# ਵੈੱਬ ਸਰਵਰ ਗਰੁੱਪ
[webservers]
web1.example.com
web2.example.com
web3.example.com

# ਡਾਟਾਬੇਸ ਸਰਵਰ ਗਰੁੱਪ
[databases]
db1.example.com ansible_host=192.168.1.100
db2.example.com ansible_host=192.168.1.101

# ਲੋਡ ਬੈਲੈਂਸਰ
[loadbalancers]
lb1.example.com

# ਗਰੁੱਪਾਂ ਦਾ ਗਰੁੱਪ
[production:children]
webservers
databases
loadbalancers

# ਸਾਰੇ ਵੈੱਬ ਸਰਵਰਾਂ ਲਈ ਵੈਰੀਏਬਲ
[webservers:vars]
ansible_user=deploy
ansible_port=22
http_port=80
https_port=443

# ਸਾਰੇ ਹੋਸਟਾਂ ਲਈ ਵੈਰੀਏਬਲ
[all:vars]
ansible_python_interpreter=/usr/bin/python3

ਸਥਿਰ ਇਨਵੈਂਟਰੀ (YAML ਫਾਰਮੈਟ, 2026 ਵਿੱਚ ਸਿਫ਼ਾਰਸ਼ੀ)

# inventory/hosts.yml
all:
  vars:
    ansible_python_interpreter: /usr/bin/python3
  children:
    webservers:
      hosts:
        web1.example.com:
        web2.example.com:
        web3.example.com:
      vars:
        ansible_user: deploy
        http_port: 80
        https_port: 443
    databases:
      hosts:
        db1.example.com:
          ansible_host: 192.168.1.100
        db2.example.com:
          ansible_host: 192.168.1.101
      vars:
        ansible_user: dbadmin
    production:
      children:
        webservers:
        databases:

ਗਤੀਸ਼ੀਲ ਇਨਵੈਂਟਰੀ (ਕਲਾਉਡ ਪ੍ਰਦਾਤਾ)

ਕਲਾਉਡ ਵਾਤਾਵਰਣ ਲਈ ਗਤੀਸ਼ੀਲ ਇਨਵੈਂਟਰੀ ਪਲੱਗਇਨ ਵਰਤੋ:

AWS EC2:

# inventory/aws_ec2.yml
plugin: amazon.aws.ec2
regions:
  - us-east-1
  - us-west-2
filters:
  tag:Environment: production
keyed_groups:
  - key: tags.Application
    prefix: app

Azure:

# inventory/azure_rm.yml
plugin: azure.azcollection.azure_rm
include_vm_resource_groups:
  - production-rg
keyed_groups:
  - key: tags.role
    prefix: role

2. ਪਲੇਬੁੱਕ: ਆਟੋਮੇਸ਼ਨ ਦੀ ਯੋਜਨਾ

ਪਲੇਬੁੱਕ YAML ਫਾਈਲਾਂ ਹਨ, ਜੋ ਆਟੋਮੇਸ਼ਨ ਵਰਕਫਲੋ ਦਰਸਾਉਂਦੀਆਂ ਅਤੇ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਦੀ ਲੋੜੀਂਦੀ ਸਥਿਤੀ ਤੈਅ ਕਰਦੀਆਂ ਹਨ।

ਸਧਾਰਣ ਪਲੇਬੁੱਕ ਉਦਾਹਰਨ

# simple_playbook.yml
---
- name: ਵੈੱਬ ਸਰਵਰ ਸੰਰਚਿਤ ਕਰੋ
  hosts: webservers
  become: yes
  
  tasks:
    - name: Nginx ਇੰਸਟਾਲ ਕਰੋ
      apt:
        name: nginx
        state: present
        update_cache: yes
      when: ansible_os_family == "Debian"
    
    - name: Nginx ਸ਼ੁਰੂ ਅਤੇ ਸਮਰੱਥ ਕਰੋ
      service:
        name: nginx
        state: started
        enabled: yes
    
    - name: ਵੈੱਬਸਾਈਟ ਦੀ ਸਮੱਗਰੀ ਕਾਪੀ ਕਰੋ
      copy:
        src: ./website/
        dest: /var/www/html/
        owner: www-data
        group: www-data
        mode: '0644'
    
    - name: ਫਾਇਰਵਾਲ ਸੰਰਚਿਤ ਕਰੋ
      ufw:
        rule: allow
        port: '{{ item }}'
        proto: tcp
      loop:
        - 80
        - 443

ਪਲੇਬੁੱਕ ਚਲਾਉਣਾ

# ਬੁਨਿਆਦੀ ਚਲਾਉਣਾ
ansible-playbook simple_playbook.yml

# ਖਾਸ ਇਨਵੈਂਟਰੀ ਨਾਲ
ansible-playbook -i inventory/hosts.yml simple_playbook.yml

# ਖਾਸ ਹੋਸਟਾਂ ਤੱਕ ਸੀਮਿਤ ਕਰੋ
ansible-playbook simple_playbook.yml --limit web1.example.com

# ਡਰਾਈ ਰਨ (ਚੈੱਕ ਮੋਡ)
ansible-playbook simple_playbook.yml --check

# ਸਮੱਸਿਆ ਹੱਲ ਲਈ ਵਿਸਥਾਰ ਆਉਟਪੁੱਟ
ansible-playbook simple_playbook.yml -vvv

3. ਮੋਡੀਊਲ: ਦੁਬਾਰਾ ਵਰਤਣਯੋਗ ਕੰਮ ਇਕਾਈਆਂ

Ansible ਮੋਡੀਊਲ ਆਟੋਮੇਸ਼ਨ ਦੇ ਬੁਨਿਆਦੀ ਹਿੱਸੇ ਹਨ। ਹਰ ਮੋਡੀਊਲ ਖ਼ਾਸ ਕੰਮ ਕਰਦਾ ਹੈ।

ਆਮ ਮੋਡੀਊਲ (2026)

ਸਿਸਟਮ ਮੋਡੀਊਲ:

# ਪੈਕੇਜ ਪ੍ਰਬੰਧਨ
- name: ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰੋ (apt)
  apt:
    name:
      - nginx
      - git
      - python3-pip
    state: present

# ਸੇਵਾ ਪ੍ਰਬੰਧਨ
- name: ਸੇਵਾਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ
  systemd:
    name: nginx
    state: started
    enabled: yes

ਫਾਈਲ ਮੋਡੀਊਲ:

# ਫਾਈਲ ਕਾਰਵਾਈਆਂ
- name: ਡਾਇਰੈਕਟਰੀ ਬਣਾਓ
  file:
    path: /opt/myapp
    state: directory
    owner: appuser
    mode: '0755'

# ਫਾਈਲਾਂ ਕਾਪੀ ਕਰੋ
- name: ਸੰਰਚਨਾ ਤਾਇਨਾਤ ਕਰੋ
  copy:
    src: config.yml
    dest: /etc/myapp/config.yml
    backup: yes

# ਵੈਰੀਏਬਲਾਂ ਵਾਲਾ ਟੈਂਪਲੇਟ
- name: nginx ਸੰਰਚਨਾ ਤਾਇਨਾਤ ਕਰੋ
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: restart nginx

ਕਲਾਉਡ ਮੋਡੀਊਲ (AWS ਉਦਾਹਰਨ):

# EC2 ਇੰਸਟੈਂਸ ਬਣਾਓ
- name: EC2 ਇੰਸਟੈਂਸ ਸ਼ੁਰੂ ਕਰੋ
  amazon.aws.ec2_instance:
    name: webserver-01
    instance_type: t3.medium
    image_id: ami-0c55b159cbfafe1f0
    region: us-east-1
    vpc_subnet_id: subnet-12345678
    security_group: web-sg
    key_name: my-keypair
    tags:
      Environment: production
      Application: web

# S3 ਬਕਟ ਬਣਾਓ
- name: S3 ਬਕਟ ਬਣਾਓ
  amazon.aws.s3_bucket:
    name: my-app-bucket
    region: us-east-1
    versioning: yes
    encryption: AES256

ਡਾਟਾਬੇਸ ਮੋਡੀਊਲ:

# MySQL ਡਾਟਾਬੇਸ ਪ੍ਰਬੰਧਨ
- name: MySQL ਡਾਟਾਬੇਸ ਬਣਾਓ
  mysql_db:
    name: webapp_db
    state: present
    login_user: root
    login_password: "{{ mysql_root_password }}"

- name: MySQL ਵਰਤੋਂਕਾਰ ਬਣਾਓ
  mysql_user:
    name: webapp_user
    password: "{{ db_password }}"
    priv: 'webapp_db.*:ALL'
    state: present

4. ਵੇਰੀਏਬਲ: ਪਲੇਬੁੱਕ ਨੂੰ ਲਚਕੀਲਾ ਬਣਾਉਣਾ

ਵੇਰੀਏਬਲ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਪਲੇਬੁੱਕ ਮੁੜ ਵਰਤਣ ਦਿੰਦੇ ਹਨ।

ਵੇਰੀਏਬਲ ਦੀ ਤਰਜੀਹ (ਉੱਚ ਤੋਂ ਘੱਟ)

  1. ਵਾਧੂ ਵੇਰੀਏਬਲ (ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ -e)
  2. ਟਾਸਕ ਵੇਰੀਏਬਲ
  3. ਬਲਾਕ ਵੇਰੀਏਬਲ
  4. ਰੋਲ ਅਤੇ include ਵੇਰੀਏਬਲ
  5. ਪਲੇ ਵੇਰੀਏਬਲ
  6. ਹੋਸਟ ਫੈਕਟ
  7. ਪਲੇਬੁੱਕ ਦੇ host_vars
  8. ਪਲੇਬੁੱਕ ਦੇ group_vars
  9. ਇਨਵੈਂਟਰੀ ਦੇ host_vars
  10. ਇਨਵੈਂਟਰੀ ਦੇ group_vars
  11. ਰੋਲ ਦੇ ਡਿਫਾਲਟ ਮੁੱਲ

ਵੇਰੀਏਬਲ ਦੀਆਂ ਉਦਾਹਰਨਾਂ

ਪਲੇਬੁੱਕ ਵੇਰੀਏਬਲ:

---
- name: ਐਪਲੀਕੇਸ਼ਨ ਤਾਇਨਾਤ ਕਰੋ
  hosts: webservers
  vars:
    app_name: myapp
    app_version: 2.5.0
    app_port: 8080
  
  tasks:
    - name: "{{ app_name }} ਵਰਜਨ {{ app_version }} ਤਾਇਨਾਤ ਕਰੋ"
      docker_container:
        name: "{{ app_name }}"
        image: "registry.example.com/{{ app_name }}:{{ app_version }}"
        ports:
          - "{{ app_port }}:8080"

group_vars (ਵਾਤਾਵਰਣ ਅਨੁਸਾਰ):

# group_vars/production.yml
app_environment: production
db_host: prod-db.example.com
db_port: 3306
log_level: warning
max_connections: 1000

# group_vars/development.yml
app_environment: development
db_host: dev-db.example.com
db_port: 3306
log_level: debug
max_connections: 100

Ansible Vault (ਇਨਕ੍ਰਿਪਟ ਕੀਤੇ ਵੇਰੀਏਬਲ):

# ਇਨਕ੍ਰਿਪਟ ਕੀਤੀ ਫਾਈਲ ਬਣਾਓ
ansible-vault create secrets.yml

# ਇਨਕ੍ਰਿਪਟ ਕੀਤੀ ਫਾਈਲ ਸੋਧੋ
ansible-vault edit secrets.yml

# secrets.yml ਦੀ ਸਮੱਗਰੀ:
# db_password: supersecret123
# api_key: abc123xyz789

# ਪਲੇਬੁੱਕ ਵਿੱਚ ਵਰਤੋ
ansible-playbook deploy.yml --ask-vault-pass

5. ਰੋਲ: ਜਟਿਲ ਆਟੋਮੇਸ਼ਨ ਦਾ ਪ੍ਰਬੰਧ

ਰੋਲ ਪਲੇਬੁੱਕ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦਾ ਢਾਂਚਾਗਤ ਤਰੀਕਾ ਦਿੰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਉਹ ਮੋਡੀਊਲਰ ਅਤੇ ਮੁੜ ਵਰਤਣਯੋਗ ਬਣਦੇ ਹਨ।

ਰੋਲ ਦਾ ਪੂਰਾ ਢਾਂਚਾ

roles/
└── nginx/
    ├── defaults/
    │   └── main.yml          # ਡਿਫਾਲਟ ਵੈਰੀਏਬਲ
    ├── vars/
    │   └── main.yml          # ਰੋਲ ਵੈਰੀਏਬਲ
    ├── tasks/
    │   ├── main.yml          # ਮੁੱਖ ਟਾਸਕ ਸੂਚੀ
    │   ├── install.yml       # ਇੰਸਟਾਲੇਸ਼ਨ ਟਾਸਕ
    │   └── configure.yml     # ਸੰਰਚਨਾ ਟਾਸਕ
    ├── handlers/
    │   └── main.yml          # ਹੈਂਡਲਰ (ਸੇਵਾਵਾਂ ਮੁੜ ਚਾਲੂ ਕਰੋ)
    ├── templates/
    │   ├── nginx.conf.j2     # Jinja2 ਟੈਂਪਲੇਟ
    │   └── site.conf.j2
    ├── files/
    │   └── custom_module.sh  # ਸਥਿਰ ਫਾਈਲਾਂ
    ├── meta/
    │   └── main.yml          # ਰੋਲ ਨਿਰਭਰਤਾਵਾਂ
    └── README.md             # ਦਸਤਾਵੇਜ਼

ਰੋਲ ਦੀ ਉਦਾਹਰਨ: nginx

defaults/main.yml:

---
nginx_port: 80
nginx_user: www-data
nginx_worker_processes: auto
nginx_worker_connections: 1024

tasks/main.yml:

---
- name: OS-ਖਾਸ ਵੈਰੀਏਬਲ ਸ਼ਾਮਲ ਕਰੋ
  include_vars: "{{ ansible_os_family }}.yml"

- name: Nginx ਇੰਸਟਾਲ ਕਰੋ
  include_tasks: install.yml

- name: Nginx ਸੰਰਚਿਤ ਕਰੋ
  include_tasks: configure.yml

- name: ਯਕੀਨੀ ਬਣਾਓ ਕਿ Nginx ਚੱਲ ਰਿਹਾ ਹੈ
  service:
    name: nginx
    state: started
    enabled: yes

tasks/install.yml:

---
- name: Nginx ਇੰਸਟਾਲ ਕਰੋ (Debian)
  apt:
    name: nginx
    state: present
    update_cache: yes
  when: ansible_os_family == "Debian"

- name: Nginx ਇੰਸਟਾਲ ਕਰੋ (RedHat)
  yum:
    name: nginx
    state: present
  when: ansible_os_family == "RedHat"

handlers/main.yml:

---
- name: nginx ਮੁੜ ਚਾਲੂ ਕਰੋ
  service:
    name: nginx
    state: restarted

- name: nginx ਮੁੜ ਲੋਡ ਕਰੋ
  service:
    name: nginx
    state: reloaded

templates/nginx.conf.j2:

user {{ nginx_user }};
worker_processes {{ nginx_worker_processes }};

events {
    worker_connections {{ nginx_worker_connections }};
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    
    server {
        listen {{ nginx_port }};
        server_name {{ ansible_fqdn }};
        
        location / {
            root /var/www/html;
            index index.html;
        }
    }
}

ਰੋਲ ਵਰਤਣਾ:

---
- name: Nginx ਰੋਲ ਨਾਲ ਵੈੱਬ ਸਰਵਰ ਸੰਰਚਿਤ ਕਰੋ
  hosts: webservers
  become: yes
  
  roles:
    - role: nginx
      vars:
        nginx_port: 8080
        nginx_worker_processes: 4

Ansible ਦੀਆਂ ਉੱਨਤ ਧਾਰਨਾਵਾਂ (2026)

Ansible ਕਲੈਕਸ਼ਨ

ਕਲੈਕਸ਼ਨ Ansible ਸਮੱਗਰੀ ਵੰਡਣ ਦਾ ਫਾਰਮੈਟ ਹਨ, ਜਿਵੇਂ ਮੋਡੀਊਲ, ਰੋਲ ਅਤੇ ਪਲੱਗਇਨ।

ਕਲੈਕਸ਼ਨ ਇੰਸਟਾਲ ਕਰਨਾ

# Ansible Galaxy ਤੋਂ ਇੰਸਟਾਲ ਕਰੋ
ansible-galaxy collection install community.general
ansible-galaxy collection install amazon.aws
ansible-galaxy collection install ansible.windows

# requirements ਫਾਈਲ ਤੋਂ ਇੰਸਟਾਲ ਕਰੋ
# requirements.yml:
collections:
  - name: community.general
    version: ">=6.0.0"
  - name: amazon.aws
    version: "5.2.0"

ansible-galaxy collection install -r requirements.yml

ਕਲੈਕਸ਼ਨ ਮੋਡੀਊਲ ਵਰਤਣਾ

---
- name: ਕਲੈਕਸ਼ਨ ਮੋਡੀਊਲ ਵਰਤੋ
  hosts: localhost
  tasks:
    - name: community.general ਦਾ Docker ਮੋਡੀਊਲ ਵਰਤੋ
      community.general.docker_container:
        name: webapp
        image: nginx:latest
    
    - name: AWS EC2 ਮੋਡੀਊਲ ਵਰਤੋ
      amazon.aws.ec2_instance:
        name: webserver
        instance_type: t3.micro

Ansible Tower / AWX (ਐਂਟਰਪ੍ਰਾਈਜ਼ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ)

Ansible Tower (ਵਪਾਰਕ) ਅਤੇ AWX (ਓਪਨ-ਸੋਰਸ) ਇਹ ਸਹੂਲਤਾਂ ਦਿੰਦੇ ਹਨ:

  • ਪਲੇਬੁੱਕ ਚਲਾਉਣ ਲਈ ਵੈੱਬ UI
  • ਰੋਲ-ਅਧਾਰਿਤ ਪਹੁੰਚ ਕੰਟਰੋਲ (RBAC)
  • ਜੌਬ ਸਮਾਂ-ਸੂਚੀ ਅਤੇ ਵਰਕਫਲੋ
  • ਕੇਂਦਰੀਕ੍ਰਿਤ ਲੌਗਿੰਗ ਅਤੇ ਆਡਿਟਿੰਗ
  • ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਲਈ REST API
  • ਪ੍ਰਮਾਣ-ਪੱਤਰਾਂ ਦਾ ਪ੍ਰਬੰਧਨ
  • ਇਨਵੈਂਟਰੀ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ

Docker Compose ਨਾਲ AWX ਇੰਸਟਾਲ ਕਰਨਾ:

# AWX ਰਿਪੋਜ਼ਟਰੀ ਕਲੋਨ ਕਰੋ
git clone https://github.com/ansible/awx.git
cd awx

# docker-compose ਨਾਲ ਤਾਇਨਾਤ ਕਰੋ
cd tools/docker-compose
docker-compose -f docker-compose.yml up -d

# http://localhost:80 ਤੇ ਜਾਓ
# ਮੂਲ ਲਾਗਇਨ: admin / password

Ansible ਨਾਲ Windows ਆਟੋਮੇਸ਼ਨ

2026 ਵਿੱਚ Ansible ਦਾ Windows ਸਮਰਥਨ ਕਾਫ਼ੀ ਸੁਧਰਿਆ ਹੈ:

Windows ਦੀਆਂ ਪੂਰਵ-ਲੋੜਾਂ:

# Windows ਹੋਸਟ ਤੇ WinRM ਚਾਲੂ ਕਰੋ
$url = "https://raw.githubusercontent.com/ansible/ansible/devel/examples/scripts/ConfigureRemotingForAnsible.ps1"
$file = "$env:temp\ConfigureRemotingForAnsible.ps1"
(New-Object -TypeName System.Net.WebClient).DownloadFile($url, $file)
powershell.exe -ExecutionPolicy ByPass -File $file

Windows ਇਨਵੈਂਟਰੀ:

[windows]
win1.example.com

[windows:vars]
ansible_user=Administrator
ansible_password=SecurePassword123
ansible_connection=winrm
ansible_winrm_transport=ntlm
ansible_winrm_server_cert_validation=ignore
ansible_port=5986

Windows ਆਟੋਮੇਸ਼ਨ ਪਲੇਬੁੱਕ:

---
- name: Windows ਸਰਵਰ ਸੰਰਚਨਾ
  hosts: windows
  gather_facts: yes
  
  tasks:
    - name: IIS ਇੰਸਟਾਲ ਕਰੋ
      win_feature:
        name: Web-Server
        state: present
        include_management_tools: yes
    
    - name: ਵੈੱਬਸਾਈਟ ਤਾਇਨਾਤ ਕਰੋ
      win_copy:
        src: ./website/
        dest: C:\inetpub\wwwroot\
    
    - name: ਫਾਇਰਵਾਲ ਸੰਰਚਿਤ ਕਰੋ
      win_firewall_rule:
        name: HTTP ਦੀ ਇਜਾਜ਼ਤ ਦਿਓ
        localport: 80
        protocol: tcp
        action: allow
        direction: in
        enabled: yes
    
    - name: Chocolatey ਰਾਹੀਂ ਸਾਫਟਵੇਅਰ ਇੰਸਟਾਲ ਕਰੋ
      win_chocolatey:
        name:
          - googlechrome
          - 7zip
          - notepadplusplus
        state: present

Ansible ਨਾਲ ਨੈੱਟਵਰਕ ਆਟੋਮੇਸ਼ਨ

Ansible Cisco, Juniper, Arista ਅਤੇ F5 ਸਮੇਤ ਵੱਡੇ ਨੈੱਟਵਰਕ ਵਿਕਰੇਤਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।

ਨੈੱਟਵਰਕ ਡਿਵਾਈਸ ਪਲੇਬੁੱਕ:

---
- name: Cisco ਸਵਿੱਚ ਸੰਰਚਿਤ ਕਰੋ
  hosts: cisco_switches
  gather_facts: no
  connection: network_cli
  
  vars:
    ansible_network_os: ios
    ansible_user: admin
    ansible_password: "{{ vault_switch_password }}"
  
  tasks:
    - name: VLAN ਸੰਰਚਿਤ ਕਰੋ
      cisco.ios.ios_vlans:
        config:
          - vlan_id: 10
            name: DATA
          - vlan_id: 20
            name: VOICE
          - vlan_id: 30
            name: GUEST
        state: merged
    
    - name: ਇੰਟਰਫੇਸ ਸੰਰਚਿਤ ਕਰੋ
      cisco.ios.ios_interfaces:
        config:
          - name: GigabitEthernet1/0/1
            description: Uplink to Core
            enabled: true
    
    - name: ਸੰਰਚਨਾ ਸੰਭਾਲੋ
      cisco.ios.ios_config:
        save_when: always

ਅਸਲ ਵਰਤੋਂ ਦੇ ਮਾਮਲੇ ਅਤੇ ਉਦਾਹਰਨਾਂ

ਵਰਤੋਂ ਦਾ ਮਾਮਲਾ 1: ਪੂਰੀ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਡਿਪਲੌਇ ਕਰਨਾ

ਪ੍ਰੋਜੈਕਟ ਢਾਂਚਾ:

webapp-deployment/
├── ansible.cfg
├── inventory/
│   ├── production
│   └── staging
├── group_vars/
│   ├── all.yml
│   ├── production.yml
│   └── staging.yml
├── roles/
│   ├── common/
│   ├── nginx/
│   ├── postgresql/
│   └── application/
└── playbooks/
    ├── site.yml
    └── deploy.yml

site.yml (ਪੂਰਾ ਸਟੈਕ ਡਿਪਲੌਇਮੈਂਟ):

---
- name: ਸਾਰੇ ਸਰਵਰ ਸੰਰਚਿਤ ਕਰੋ
  hosts: all
  become: yes
  roles:
    - common

- name: ਡਾਟਾਬੇਸ ਸਰਵਰ ਸੰਰਚਿਤ ਕਰੋ
  hosts: databases
  become: yes
  roles:
    - postgresql

- name: ਵੈੱਬ ਸਰਵਰ ਸੰਰਚਿਤ ਕਰੋ
  hosts: webservers
  become: yes
  roles:
    - nginx
    - application

- name: ਲੋਡ ਬੈਲੈਂਸਰ ਸੰਰਚਿਤ ਕਰੋ
  hosts: loadbalancers
  become: yes
  roles:
    - haproxy

ਵਰਤੋਂ ਦਾ ਮਾਮਲਾ 2: Kubernetes ਕਲੱਸਟਰ ਸੈੱਟਅੱਪ

---
- name: Kubernetes ਕਲੱਸਟਰ ਸੈੱਟਅੱਪ ਕਰੋ
  hosts: k8s_cluster
  become: yes
  
  tasks:
    - name: Docker ਇੰਸਟਾਲ ਕਰੋ
      apt:
        name: docker.io
        state: present
    
    - name: Kubernetes apt ਕੁੰਜੀ ਸ਼ਾਮਲ ਕਰੋ
      apt_key:
        url: https://packages.cloud.google.com/apt/doc/apt-key.gpg
        state: present
    
    - name: Kubernetes ਰਿਪੋਜ਼ਟਰੀ ਸ਼ਾਮਲ ਕਰੋ
      apt_repository:
        repo: deb https://apt.kubernetes.io/ kubernetes-xenial main
        state: present
    
    - name: Kubernetes ਹਿੱਸੇ ਇੰਸਟਾਲ ਕਰੋ
      apt:
        name:
          - kubelet=1.28.0-00
          - kubeadm=1.28.0-00
          - kubectl=1.28.0-00
        state: present

- name: Kubernetes ਮਾਸਟਰ ਸ਼ੁਰੂ ਕਰੋ
  hosts: k8s_master
  become: yes
  tasks:
    - name: ਕਲੱਸਟਰ ਸ਼ੁਰੂ ਕਰੋ
      command: kubeadm init --pod-network-cidr=10.244.0.0/16
      args:
        creates: /etc/kubernetes/admin.conf
    
    - name: .kube ਡਾਇਰੈਕਟਰੀ ਬਣਾਓ
      file:
        path: /home/{{ ansible_user }}/.kube
        state: directory
        owner: "{{ ansible_user }}"
    
    - name: admin.conf ਕਾਪੀ ਕਰੋ
      copy:
        src: /etc/kubernetes/admin.conf
        dest: /home/{{ ansible_user }}/.kube/config
        remote_src: yes
        owner: "{{ ansible_user }}"

ਵਰਤੋਂ ਦਾ ਮਾਮਲਾ 3: ਸੁਰੱਖਿਆ ਮਜ਼ਬੂਤ ਕਰਨਾ ਆਟੋਮੇਟ ਕਰਨਾ

---
- name: ਸੁਰੱਖਿਆ ਮਜ਼ਬੂਤ ਕਰੋ
  hosts: all
  become: yes
  
  tasks:
    - name: ਸਾਰੇ ਪੈਕੇਜ ਅੱਪਡੇਟ ਕਰੋ
      apt:
        upgrade: dist
        update_cache: yes
    
    - name: ਸੁਰੱਖਿਆ ਟੂਲ ਇੰਸਟਾਲ ਕਰੋ
      apt:
        name:
          - fail2ban
          - ufw
          - aide
        state: present
    
    - name: fail2ban ਸੰਰਚਿਤ ਕਰੋ
      copy:
        src: jail.local
        dest: /etc/fail2ban/jail.local
      notify: restart fail2ban
    
    - name: ਫਾਇਰਵਾਲ ਸੰਰਚਿਤ ਕਰੋ
      ufw:
        rule: "{{ item.rule }}"
        port: "{{ item.port }}"
        proto: "{{ item.proto }}"
      loop:
        - { rule: 'allow', port: '22', proto: 'tcp' }
        - { rule: 'allow', port: '80', proto: 'tcp' }
        - { rule: 'allow', port: '443', proto: 'tcp' }
        - { rule: 'deny', port: '3306', proto: 'tcp' }
    
    - name: ਫਾਇਰਵਾਲ ਚਾਲੂ ਕਰੋ
      ufw:
        state: enabled
    
    - name: root ਲਾਗਇਨ ਬੰਦ ਕਰੋ
      lineinfile:
        path: /etc/ssh/sshd_config
        regexp: '^PermitRootLogin'
        line: 'PermitRootLogin no'
      notify: restart sshd
    
    - name: ਪਾਸਵਰਡ ਨੀਤੀ ਨਿਰਧਾਰਤ ਕਰੋ
      lineinfile:
        path: /etc/login.defs
        regexp: '^PASS_MAX_DAYS'
        line: 'PASS_MAX_DAYS   90'
  
  handlers:
    - name: fail2ban ਮੁੜ ਚਾਲੂ ਕਰੋ
      service:
        name: fail2ban
        state: restarted
    
    - name: sshd ਮੁੜ ਚਾਲੂ ਕਰੋ
      service:
        name: sshd
        state: restarted

Ansible ਲਈ ਵਧੀਆ ਅਭਿਆਸ (2026 ਸੰਸਕਰਣ)

1. ਵਰਜਨ ਕੰਟਰੋਲ (Git) ਵਰਤੋ

ਰਿਪੋਜ਼ਟਰੀ ਢਾਂਚਾ:

ansible-infrastructure/
├── .gitignore
├── README.md
├── ansible.cfg
├── inventory/
├── group_vars/
├── host_vars/
├── roles/
├── playbooks/
└── files/

.gitignore:

*.retry
*.pyc
.vault_pass
secrets.yml
*.log

2. ਇਡੈਂਪੋਟੈਂਸੀ ਲਾਗੂ ਕਰੋ

ਗਲਤ (ਇਡੈਂਪੋਟੈਂਟ ਨਹੀਂ):

- name: ਫਾਈਲ ਵਿੱਚ ਲਾਈਨ ਜੋੜੋ
  shell: echo "new line" >> /etc/myconfig

ਸਹੀ (ਇਡੈਂਪੋਟੈਂਟ):

- name: ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਲਾਈਨ ਫਾਈਲ ਵਿੱਚ ਹੈ
  lineinfile:
    path: /etc/myconfig
    line: "new line"
    state: present

3. ਕੋਡ ਗੁਣਵੱਤਾ ਲਈ Ansible Lint ਵਰਤੋ

# ansible-lint ਇੰਸਟਾਲ ਕਰੋ
pip install ansible-lint

# ਲਿੰਟਰ ਚਲਾਓ
ansible-lint playbook.yml

# ਆਮ ਸਮੱਸਿਆਵਾਂ ਆਪਣੇ ਆਪ ਠੀਕ ਕਰੋ
ansible-lint --fix playbook.yml

4. Molecule ਨਾਲ ਟੈਸਟ ਕਰੋ

# Molecule ਇੰਸਟਾਲ ਕਰੋ
pip install molecule molecule-docker

# ਟੈਸਟਾਂ ਨਾਲ ਨਵਾਂ ਰੋਲ ਸ਼ੁਰੂ ਕਰੋ
molecule init role my_role --driver-name docker

# ਟੈਸਟ ਚਲਾਓ
cd my_role
molecule test

# ਟੈਸਟ ਦੇ ਪੜਾਅ:
# - ਟੈਸਟ ਵਾਤਾਵਰਣ ਬਣਾਓ
# - ਕਨਵਰਜ ਕਰੋ (ਪਲੇਬੁੱਕ ਚਲਾਓ)
# - ਜਾਂਚੋ (ਟੈਸਟ ਚਲਾਓ)
# - ਵਾਤਾਵਰਣ ਮਿਟਾਓ

molecule.yml ਦੀ ਉਦਾਹਰਨ:

---
dependency:
  name: galaxy
driver:
  name: docker
platforms:
  - name: ubuntu2204
    image: geerlingguy/docker-ubuntu2204-ansible:latest
    pre_build_image: true
provisioner:
  name: ansible
verifier:
  name: ansible

5. ਚੋਣਵੀਂ ਕਾਰਵਾਈ ਲਈ ਟੈਗ ਵਰਤੋ

---
- name: ਪੂਰਾ ਸਰਵਰ ਸੈੱਟਅੱਪ
  hosts: webservers
  become: yes
  
  tasks:
    - name: ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰੋ
      apt:
        name: nginx
        state: present
      tags:
        - packages
        - nginx
    
    - name: Nginx ਸੰਰਚਿਤ ਕਰੋ
      template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
      tags:
        - configuration
        - nginx
    
    - name: ਐਪਲੀਕੇਸ਼ਨ ਤਾਇਨਾਤ ਕਰੋ
      copy:
        src: app/
        dest: /var/www/html/
      tags:
        - deployment
        - application

# ਸਿਰਫ਼ nginx ਟਾਸਕ ਚਲਾਓ
# ansible-playbook play.yml --tags nginx

# ਤਾਇਨਾਤੀ ਛੱਡੋ
# ansible-playbook play.yml --skip-tags deployment

6. ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਅਤੇ ਡੀਬੱਗਿੰਗ

---
- name: ਮਜ਼ਬੂਤ ਟਾਸਕ ਚਲਾਉਣਾ
  hosts: webservers
  
  tasks:
    - name: ਖਤਰਨਾਕ ਕਾਰਵਾਈ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ
      command: /usr/bin/risky_command
      register: result
      failed_when: false
      changed_when: result.rc == 0
    
    - name: ਡੀਬੱਗ ਆਉਟਪੁੱਟ
      debug:
        var: result
        verbosity: 2
    
    - name: ਅਸਫਲਤਾ ਸੰਭਾਲੋ
      debug:
        msg: "ਕਮਾਂਡ ਅਸਫਲ ਹੋਈ, ਪਰ ਕਾਰਵਾਈ ਜਾਰੀ ਹੈ..."
      when: result.rc != 0
    
    - name: ਰਿਕਵਰੀ ਵਾਲਾ ਬਲਾਕ
      block:
        - name: ਪਹਿਲਾਂ ਇਹ ਅਜ਼ਮਾਓ
          command: /may/fail
        
        - name: ਸਫਲ ਹੋਣ ਤੇ ਇਹ ਕਰੋ
          debug:
            msg: "ਸਫਲਤਾ!"
      
      rescue:
        - name: ਅਸਫਲ ਹੋਣ ਤੇ ਇਸ ਦੀ ਥਾਂ ਇਹ ਕਰੋ
          debug:
            msg: "ਅਸਫਲਤਾ ਤੋਂ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤਾ"
      
      always:
        - name: ਇਹ ਹਮੇਸ਼ਾ ਚਲਾਓ
          debug:
            msg: "ਸਫਾਈ ਕਾਰਵਾਈਆਂ"

7. ਕਾਰਗੁਜ਼ਾਰੀ ਸੁਧਾਰੋ

Pipelining ਚਾਲੂ ਕਰੋ

# ansible.cfg
[defaults]
pipelining = True

Mitogen ਵਰਤੋ (3-7 ਗੁਣਾ ਤੇਜ਼)

# Mitogen ਇੰਸਟਾਲ ਕਰੋ
pip install mitogen
# ansible.cfg
[defaults]
strategy_plugins = /path/to/mitogen/ansible_mitogen/plugins/strategy
strategy = mitogen_linear

ਸਮਾਂਤਰ ਕਾਰਵਾਈ

---
- name: ਸਮਾਂਤਰ ਅੱਪਡੇਟ
  hosts: all
  strategy: free  # ਸਾਰੇ ਹੋਸਟਾਂ ਦੀ ਉਡੀਕ ਨਾ ਕਰੋ
  serial: 10      # ਇੱਕ ਵਾਰ ਵਿੱਚ 10 ਹੋਸਟਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੋ
  
  tasks:
    - name: ਪੈਕੇਜ ਅੱਪਡੇਟ ਕਰੋ
      apt:
        upgrade: dist

ਆਮ ਸਮੱਸਿਆਵਾਂ ਦਾ ਹੱਲ

ਸਮੱਸਿਆ 1: SSH ਕਨੈਕਸ਼ਨ ਅਸਫਲ

ਸਮੱਸਿਆ: ਪ੍ਰਬੰਧਿਤ ਹੋਸਟ ਨਾਲ ਜੁੜਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ

ਹੱਲ:

# ਕੱਚੇ SSH ਕਨੈਕਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ
ssh -vvv user@host

# Ansible ਕਨੈਕਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ
ansible host -m ping -vvv

# ਇਨਵੈਂਟਰੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ
[all:vars]
ansible_ssh_common_args='-o StrictHostKeyChecking=no'

ਸਮੱਸਿਆ 2: ਪਹੁੰਚ ਮਨਜ਼ੂਰ ਨਹੀਂ (sudo)

ਸਮੱਸਿਆ: ਅਨੁਮਤੀ ਗਲਤੀ ਕਾਰਨ ਟਾਸਕ ਅਸਫਲ ਹੁੰਦੇ ਹਨ

ਹੱਲ:

---
- hosts: webservers
  become: yes
  become_method: sudo
  become_user: root
  
  tasks:
    - name: root ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ ਵਾਲਾ ਟਾਸਕ
      file:
        path: /etc/myconfig
        state: touch

ਸਮੱਸਿਆ 3: ਮੋਡੀਊਲ ਨਹੀਂ ਮਿਲਿਆ

ਸਮੱਸਿਆ: ਮੋਡੀਊਲ ਨਾ ਮਿਲਣ ਦੀਆਂ ਗਲਤੀਆਂ

ਹੱਲ:

# ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕਲੈਕਸ਼ਨ ਇੰਸਟਾਲ ਹੈ
ansible-galaxy collection install community.general

# ਕਲੈਕਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ
ansible-galaxy collection list

# FQCN (ਪੂਰਾ ਯੋਗ ਕਲੈਕਸ਼ਨ ਨਾਮ) ਵਰਤੋ
community.general.docker_container:
  name: mycontainer

ਸਮੱਸਿਆ 4: ਪਲੇਬੁੱਕ ਹੌਲੀ ਚੱਲਦੀ ਹੈ

ਹੱਲ:

  1. Pipelining ਚਾਲੂ ਕਰੋ (ਕਾਰਗੁਜ਼ਾਰੀ ਭਾਗ ਵੇਖੋ)
  2. Mitogen ਰਣਨੀਤੀ ਪਲੱਗਇਨ ਵਰਤੋ
  3. ਲੋੜ ਨਾ ਹੋਵੇ ਤਾਂ ਫੈਕਟ ਇਕੱਠੇ ਕਰਨਾ ਬੰਦ ਕਰੋ:
    - hosts: all
      gather_facts: no
    
  4. ਲੰਬੇ ਕੰਮਾਂ ਲਈ ਅਸਿੰਕ੍ਰੋਨਸ ਚਲਾਉਣਾ ਵਰਤੋ:
    - name: ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲਾ ਟਾਸਕ
      command: /usr/bin/long_task
      async: 3600
      poll: 0
    

Ansible ਕਰੀਅਰ ਰਾਹ ਅਤੇ ਸਰਟੀਫਿਕੇਸ਼ਨ

ਹੁਨਰਾਂ ਦੀ ਤਰੱਕੀ

ਸ਼ੁਰੂਆਤੀ (0-6 ਮਹੀਨੇ):

  • ਬੁਨਿਆਦੀ ਪਲੇਬੁੱਕ ਲਿਖੋ
  • ਇਨਵੈਂਟਰੀ ਅਤੇ ਵੇਰੀਏਬਲ ਸਮਝੋ
  • ਆਮ ਮੋਡੀਊਲ ਵਰਤੋ
  • ਪਲੇਬੁੱਕ ਚਲਾਓ

ਦਰਮਿਆਨਾ (6-18 ਮਹੀਨੇ):

  • ਮੁੜ ਵਰਤਣਯੋਗ ਰੋਲ ਬਣਾਓ
  • ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਲਾਗੂ ਕਰੋ
  • Ansible Vault ਵਰਤੋ
  • CI/CD ਨਾਲ ਜੋੜੋ
  • ਕਈ ਵਾਤਾਵਰਣਾਂ ਦਾ ਪ੍ਰਬੰਧ ਕਰੋ

ਉੱਨਤ (18 ਮਹੀਨਿਆਂ ਤੋਂ ਵੱਧ):

  • ਜਟਿਲ ਆਟੋਮੇਸ਼ਨ ਫਰੇਮਵਰਕ ਤਿਆਰ ਕਰੋ
  • ਕਸਟਮ ਮੋਡੀਊਲ ਅਤੇ ਪਲੱਗਇਨ ਬਣਾਓ
  • Tower/AWX ਡਿਪਲੌਇਮੈਂਟ ਤਿਆਰ ਕਰੋ
  • ਕਾਰਗੁਜ਼ਾਰੀ ਸੁਧਾਰੋ
  • ਹੋਰਨਾਂ ਨੂੰ ਸਿਖਾਓ

ਸਰਟੀਫਿਕੇਸ਼ਨ

Red Hat Certified Specialist in Ansible Automation (EX407)

  • Ansible ਦੀ ਮੁਹਾਰਤ ਦਿਖਾਉਂਦਾ ਹੈ
  • ਕੰਮ-ਅਧਾਰਿਤ ਪ੍ਰਯੋਗਿਕ ਪ੍ਰੀਖਿਆ
  • 3 ਸਾਲ ਲਈ ਵੈਧ
  • ਉਦਯੋਗ ਵਿੱਚ ਮੰਨਿਆ ਹੋਇਆ

ਤਿਆਰੀ ਲਈ ਸਰੋਤ:

  • Red Hat Learning Subscription
  • Ansible ਦਸਤਾਵੇਜ਼
  • ਅਭਿਆਸ ਲੈਬ (A Cloud Guru, Udemy)
  • ਕਮਿਊਨਿਟੀ ਫੋਰਮ

ਨੌਕਰੀ ਬਾਜ਼ਾਰ (2026)

ਅਮਰੀਕਾ ਵਿੱਚ ਔਸਤ ਤਨਖਾਹ:

  • ਜੂਨੀਅਰ Ansible ਇੰਜੀਨੀਅਰ: $75,000-$95,000
  • ਦਰਮਿਆਨੇ ਪੱਧਰ ਦਾ DevOps ਇੰਜੀਨੀਅਰ (Ansible): $110,000-$140,000
  • ਸੀਨੀਅਰ ਆਟੋਮੇਸ਼ਨ ਆਰਕੀਟੈਕਟ: $150,000-$190,000

ਮੰਗ ਵਾਲੇ ਹੁਨਰ:

  • Ansible ਅਤੇ Kubernetes
  • Ansible ਅਤੇ Terraform (ਹਾਈਬ੍ਰਿਡ IaC)
  • Ansible ਅਤੇ CI/CD (Jenkins, GitLab)
  • Ansible ਅਤੇ ਕਲਾਉਡ (AWS, Azure, GCP)
  • Ansible Tower/AWX ਪ੍ਰਸ਼ਾਸਨ

ਸਿੱਖਣ ਦੇ ਸਰੋਤ ਅਤੇ ਕਮਿਊਨਿਟੀ

ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼

ਆਨਲਾਈਨ ਕੋਰਸ

  • Red Hat Learning Subscription
  • Udemy: ਬਿਲਕੁਲ ਨਵੇਂ ਲੋਕਾਂ ਲਈ Ansible
  • A Cloud Guru: ਵਿਹਾਰਕ Ansible
  • Linux Academy: Ansible ਤੁਰੰਤ ਸ਼ੁਰੂਆਤ

ਕਿਤਾਬਾਂ

  • Jeff Geerling ਦੀ Ansible for DevOps (2025 ਵਿੱਚ ਅੱਪਡੇਟ)
  • Lorin Hochstein ਦੀ Ansible: Up and Running
  • James Freeman ਦੀ Mastering Ansible

ਕਮਿਊਨਿਟੀ

ਅਭਿਆਸ ਪਲੇਟਫਾਰਮ

ਨਤੀਜਾ: Ansible ਨਾਲ ਆਪਣਾ ਸਫ਼ਰ ਸ਼ੁਰੂ ਕਰੋ

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

ਮੁੱਖ ਗੱਲਾਂ:

  1. ਸੌਖਾ ਸ਼ੁਰੂ ਕਰੋ: ਕੁਝ ਸਰਵਰਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਬੁਨਿਆਦੀ ਪਲੇਬੁੱਕ ਬਣਾਓ
  2. ਨਿਯਮਿਤ ਅਭਿਆਸ ਕਰੋ: ਘਰੇਲੂ ਲੈਬ ਸੈੱਟ ਕਰੋ ਅਤੇ ਪ੍ਰਯੋਗ ਕਰੋ
  3. ਕਰ ਕੇ ਸਿੱਖੋ: ਆਪਣੇ ਰੋਜ਼ਾਨਾ ਕੰਮ ਦੇ ਅਸਲ ਟਾਸਕ ਆਟੋਮੇਟ ਕਰੋ
  4. ਵਧੀਆ ਅਭਿਆਸ ਅਪਣਾਓ: ਵਰਜਨ ਕੰਟਰੋਲ, ਟੈਸਟਿੰਗ ਅਤੇ ਦਸਤਾਵੇਜ਼ ਵਰਤੋ
  5. ਕਮਿਊਨਿਟੀ ਨਾਲ ਜੁੜੋ: ਹੋਰਨਾਂ ਤੋਂ ਸਿੱਖੋ ਅਤੇ ਆਪਣਾ ਗਿਆਨ ਸਾਂਝਾ ਕਰੋ
  6. ਅੱਪਡੇਟ ਰਹੋ: Ansible ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਦਾ ਹੈ, ਸਿੱਖਦੇ ਰਹੋ
  7. ਟੂਲ ਜੋੜੋ: Ansible, Terraform ਅਤੇ Kubernetes ਮਿਲ ਕੇ ਵਿਆਪਕ ਆਟੋਮੇਸ਼ਨ ਕਰਦੇ ਹਨ

ਅਗਲੇ ਕਦਮ:

  1. ਆਪਣੇ ਸਿਸਟਮ ਉੱਤੇ Ansible ਇੰਸਟਾਲ ਕਰੋ
  2. ਟੈਸਟ ਸਰਵਰਾਂ, ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਜਾਂ ਕੰਟੇਨਰਾਂ ਦੀ ਸਧਾਰਣ ਇਨਵੈਂਟਰੀ ਬਣਾਓ
  3. ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਆਪਣਾ ਪਹਿਲਾ ਪਲੇਬੁੱਕ ਲਿਖੋ
  4. ਟੈਂਪਲੇਟ, ਵੇਰੀਏਬਲ ਅਤੇ ਰੋਲ ਜੋੜ ਕੇ ਹੌਲੀ-ਹੌਲੀ ਜਟਿਲਤਾ ਵਧਾਓ
  5. Ansible Galaxy ਉੱਤੇ ਕਮਿਊਨਿਟੀ ਰੋਲਾਂ ਵਿੱਚ ਯੋਗਦਾਨ ਪਾਓ
  6. ਆਪਣੇ ਹੁਨਰਾਂ ਦੀ ਪੁਸ਼ਟੀ ਲਈ ਸਰਟੀਫਿਕੇਸ਼ਨ ਬਾਰੇ ਸੋਚੋ

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

Ansible ਨਾਲ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਆਟੋਮੇਸ਼ਨ ਦੀ ਦੁਨੀਆ ਵਿੱਚ ਤੁਹਾਡਾ ਸੁਆਗਤ ਹੈ!


ਹਵਾਲੇ