ద్వారా Matt Connor 2026-07-16 · అప్‌డేట్ చేయబడింది 2026-07-24

Ansible tutorial: VPS లో మొదటి playbook

Q: Ansible "Permission denied (publickey)" అని ఎందుకు చెబుతోంది?

Permission denied (publickey) తో కూడిన UNREACHABLE! బ్లాక్ వల్ల, Ansible ఏదీ రన్ చేయకముందే SSH authentication విఫలమైందని అర్థం. inventory లోని ansible_user మీరు సెటప్ చేసిన అకౌంట్తో సరిపోలుతుందో లేదో చూడండి, మీరు ఆ host కి ssh-copy-id రన్ చేశారో లేదో తనిఖీ చేయండి, మరియు సాధారణ ssh user@host పాస్వర్డ్ లేకుండా లాగిన్ అవుతుందో లేదో చూడండి. సాధారణ ssh కమాండ్ దేనిని పరిష్కరిస్తే, Ansible కూడా అదే విధంగా పనిచేస్తుంది, ఎందుకంటే అవి ఒకే రకమైన transport ని ఉపయోగిస్తాయి.

Q: ansible మరియు ansible-core ప్యాకేజీల మధ్య తేడా ఏమిటి?

ansible-core అనేది engine మరియు కేవలం ansible.builtin modules మాత్రమే కలిగి ఉంటుంది. ansible ప్యాకేజీ core ని మరియు క్యూరేటెడ్ community collections ని కలిపి అందిస్తుంది — ఇందులో ఈ గైడ్లో ఉపయోగించే ansible.posix (authorized_key module) మరియు community.general (ufw module) కూడా ఉంటాయి. మొదట పూర్తి ప్యాకేజీతో ప్రారంభించండి; మీకు అవసరమైనప్పుడు మాత్రమే core మరియు ఎంచుకున్న collections కి పరిమితం చేయండి.

Ubuntu 24.04 లో pipx తో Ansible ఇన్‌స్టాల్ చేయండి. Permission denied మరియు sudo errors ని పరిష్కరిస్తూ, VPS ని harden చేసే playbook ని ఎలా రాయాలో నేర్చుకోండి.

మీరు నిర్మించబోయేది

Ansible ఇన్‌స్టాల్ చేసిన ఒక control machine, మరియు కేవలం stock image మాత్రమే ఉన్న ఒకటి లేదా అంతకంటే ఎక్కువ కొత్త Ubuntu 24.04 VPSes. చివరగా, మీ సర్వర్‌ల పేర్లతో కూడిన ఒక inventory file, అథెంటికేషన్ సరిగ్గా పనిచేస్తుందని నిరూపించే ad-hoc ping, మరియు కొత్త VPS కోసం అవసరమైన అన్ని పనులను code రూపంలో చేసే ఒక playbook మీ వద్ద ఉంటాయి: మీ SSH key తో ఒక deploy user, hardened sshd, fail2ban, unattended upgrades, మరియు మిగిలినవన్నీ నిలిపివేసే ముందు OpenSSH ని అనుమతించే ఒక firewall. దీనిని ఒక సర్వర్‌కు లేదా ఇరవై సర్వర్‌లకు ఉపయోగించవచ్చు. దీనిని రెండుసార్లు రన్ చేయండి, రెండోసారి రన్ చేసినప్పుడు ఏదీ మారదు — అదే దీని ముఖ్య ఉద్దేశ్యం.

పదిహేనేళ్లగా VPSes ని provision చేస్తున్న అనుభవంతో నేను చెప్పే నిజం ఏమిటంటే: అందరూ మొదటి ఐదు సర్వర్‌లను మాన్యువల్‌గా సెటప్ చేస్తారు, కానీ ఆ మొదటి ఐదు సర్వర్‌లలో ఏమి చేశారో గుర్తులేక ఆరో సర్వర్ కోసం ఒక వారాంతాన్ని వృథా చేస్తారు. ఈ గైడ్ managing multiple Linux servers గురించి మరింత లోతైన అవగాహనను అందిస్తుంది — మీరు మూడు టెర్మినల్‌లలో ఒకే apt install ని టైప్ చేస్తున్నట్లు గమనించిన రోజున దీనిని చదవండి.

Ansible అసలు ఏమిటి, ఒక పేరాలో

Ansible అనేది agentless. ఇది నిర్వహించే సర్వర్‌లలో ఎటువంటి daemon ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు: control machine సాధారణ SSH ద్వారా కనెక్ట్ అవుతుంది, target కి ఒక చిన్న Python module ని కాపీ చేస్తుంది, దానిని ఎగ్జిక్యూట్ చేస్తుంది, అది ప్రింట్ చేసే JSON ని చదువుతుంది, మరియు దానిని డిలీట్ చేస్తుంది. target కి python3 మాత్రమే అవసరం, ఇది ప్రతి stock Ubuntu image లో ఇప్పటికే ఉంటుంది. ఇక్కడ ముఖ్యమైన పదం idempotent, దీని అర్థం చాలా స్పష్టంగా ఉంది: ఒక task ఒక state ని వివరిస్తుంది, ఒక action ని కాదు. ఒక package కి state: present అంటే "ఇది ఇన్‌స్టాల్ అయ్యి ఉందో లేదో చూడండి", "installer ని రన్ చేయండి" అని కాదు. ఒకవేళ ఆ state ఇప్పటికే ఉంటే, Ansible ఏదీ చేయదు మరియు దానిని changed కి బదులుగా ok గా రిపోర్ట్ చేస్తుంది. ఈ లక్షణమే ఈ product యొక్క ప్రధాన ఉద్దేశ్యం — దీనివల్ల playbook ని మళ్ళీ రన్ చేయడం సురక్షితం అవుతుంది, మరియు సురక్షితమైన reruns మాత్రమే ఒక shell script ని infrastructure గా మారుస్తాయి.

Prerequisites, and the gotchas up front

ఒక control machine: మీ laptop లేదా ఒక చిన్న VPS. నేను Ubuntu 24.04 ఉపయోగిస్తున్నాను; Homebrew ద్వారా pipx ఇన్‌స్టాల్ చేసుకుంటే macOS కూడా একইভাবে పనిచేస్తుంది.
KVM పైన Ubuntu 24.04 నడుపుతున్న ఒకటి లేదా అంతకంటే ఎక్కువ target VPSes, root యూజర్‌గా యాక్సెస్ చేయగలగాలి. వాటిలో ఏదీ ఇన్‌స్టాల్ చేయబడదు.
ప్రతి target కి SSH key authentication ఉండాలి. మీ ssh కమాండ్ ఏ విధంగా అయితే authenticate అవుతుందో, Ansible కూడా అలాగే పనిచేస్తుంది — ఒకవేళ ssh root@host పాస్‌వర్డ్ అడిగితే, Ansible విఫలమవుతుంది.
Ubuntu 24.04 లో, pip install ansible అనేది error: externally-managed-environment వల్ల ఆగిపోతుంది. ఇది డిస్ట్రో పాలసీ వల్ల జరుగుతుంది, ఇది లోపం కాదు. pipx ఉపయోగించండి.
YAML లో whitespace అనేది syntax. తప్పుగా indent చేస్తే mapping values are not allowed in this context వస్తుంది, మరియు ఎక్కడైనా tab character ఉపయోగిస్తే అది fatal error అవుతుంది.
Playbook sshd ని harden చేస్తున్నప్పుడు, ప్రతి target లో ఒక SSH session ని ఓపెన్ లో ఉంచండి. కస్టమర్లను నేను రికవరీ చేయడంలో ఎదురైన ప్రతి lockout కి కారణం, "to test from clean" కోసం పాత session ని క్లోజ్ చేయడం.

Step 1: pip కాకుండా pipx ఉపయోగించి control machine లో Ansible ని install చేయండి

సాధారణంగా అందరూ pip3 install ansible చేయాలనుకుంటారు. ఒకవేళ మీరు కొత్తగా install చేసిన 24.04 image ఉపయోగిస్తుంటే, మొదటి దశలోనే — Command 'pip3' not found, but can be installed with: sudo apt install python3-pip — సమస్య ఎదురవుతుంది. అప్పుడు pip ని install చేయడం వల్ల అసలైన సమస్య మొదలవుతుంది:

pip3 install ansible

error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
    python3-xyz, where xyz is the package you are trying to
    install.

Ubuntu 24.04 లో system Python ని externally managed (PEP 668) గా పరిగణిస్తారు. దీనివల్ల ఒకే ఫైల్స్ కోసం pip మరియు apt మధ్య ఘర్షణ రాకుండా నిరోధిస్తారు. కాబట్టి --break-system-packages ని ఉపయోగించవద్దు; ఆ flag పేరులోనే సమస్య స్పష్టంగా ఉంది. దీనికి సరైన పరిష్కారం pipx. ఇది Ansible కోసం ప్రత్యేకమైన isolated virtualenv ని సృష్టించి, binaries ని మీ PATH లో ఉంచుతుంది:

sudo apt update && sudo apt install -y pipx
pipx ensurepath
pipx install --include-deps ansible

PATH మార్పులు అమలు కావడానికి pipx ensurepath తర్వాత కొత్త shell ని తెరవండి. --include-deps అనేది కేవలం అలంకరణ కాదు: ansible package లో సొంతంగా console scripts ఉండవు — ansible, ansible-playbook మరియు మిగిలినవి దాని ansible-core dependency యొక్క entry points — కాబట్టి ఆ flag లేకపోతే pipx No apps associated with package ansible or its dependencies తో install చేయదు. అలాగే bare ansible-core కాకుండా ansible package ని install చేయండి — పూర్తి package లో community collections ఉంటాయి, మరియు ఈ playbook లో రెండు collections (ansible.posix మరియు community.general) యొక్క modules ఉపయోగించబడ్డాయి.

ansible --version

సరైన ఫలితం ansible [core 2.19.x] వంటి లైన్ తో ప్రారంభమవుతుంది మరియు అది రన్ అయ్యే Python ని చూపుతుంది; ఇక్కడ వాడే ఏ core release అయినా సరిపోతుంది. ఒకవేళ ansible: command not found అని వస్తే, ~/.local/bin ఇంకా మీ PATH లో లేదని అర్థం — కొత్త shell ని తెరవండి లేదా source ~/.bashrc చేయండి.

ఇది మాత్రమే install ప్రక్రియ. target machines కి ఏదీ అవసరం లేదు.

Step 2: ప్రతి target కి SSH key access

ssh-keygen -t ed25519 -C "ansible control"
ssh-copy-id root@10.0.0.10
ssh-copy-id root@10.0.0.20

తరువాత, ప్రతి host కి ఒకసారి దీనిని పరీక్షించండి:

ssh root@10.0.0.10 true && echo ok

ఆ ఒక్క లైన్ రెండు పనులను చేస్తుంది: password లేకుండా key auth పనిచేస్తుందో లేదో నిర్ధారిస్తుంది, మరియు host key ని known_hosts లో రికార్డ్ చేస్తుంది. దీనిని ఇప్పుడే చేయండి, ఎందుకంటే Ansible ఒక unrecorded host key ని చూసినప్పుడు, రన్ మధ్యలో interactive prompt గా చూపిస్తుంది. ఇది system hang అయినట్లు కనిపిస్తుంది.

Step 3: the inventory — INI first, YAML when it grows

Inventory అనేది Ansible పనిచేయగల యంత్రాల జాబితా కలిగిన ఒక text file. కొత్త project directory లో inventory.ini ని సృష్టించండి:

[vps]
web1 ansible_host=10.0.0.10
web2 ansible_host=10.0.0.20

[vps:vars]
ansible_user=root

web1 అనేది మీరు ఎంచుకునే ఒక alias — ఇది output లో కనిపిస్తుంది మరియు --limit web1 ద్వారా మీరు దీనిని target చేస్తారు. ansible_host అనేది అసలైన address. [vps] అనేది ఒక group, మరియు [vps:vars] ఆ group లోని ప్రతి host కోసం variables ని సెట్ చేస్తుంది; ansible_user అనేది Ansible ఏ user తో log in అవ్వాలో తెలియజేస్తుంది. దీని పక్కన, -i ని మళ్ళీ టైప్ చేయకుండా ఉండటానికి ansible.cfg ఉంటుంది:

[defaults]
inventory = inventory.ini

Ansible ప్రస్తుత directory నుండి ansible.cfg ని చదువుతుంది. YAML ఫార్మాట్‌లో కూడా ఇదే విధంగా inventory ఉంటుంది — దానిని inventory.yml గా సేవ్ చేసి, ansible.cfg ని ఆ పేరుకి point చేయండి — hosts కి అనేక variables ఉన్నప్పుడు మీరు దీనిని ఉపయోగించాల్సి ఉంటుంది:

vps:
  hosts:
    web1:
      ansible_host: 10.0.0.10
    web2:
      ansible_host: 10.0.0.20
  vars:
    ansible_user: root

ఈ రెండు ఫార్మాట్లు సమానమే. రెండు servers ఉన్నప్పుడు INI సులభంగా ఉంటుంది; ఇరవై servers ఉన్నప్పుడు YAML బాగా పనిచేస్తుంది. వీటిలో ఏదో ఒకటి ఎంచుకుని ముందుకు సాగండి.

Step 4: ad-hoc commands — the green pong that proves everything

ansible all -m ping

ఇది ICMP కాదు. ping module ఒక పూర్తి పరీక్ష (full dress rehearsal): SSH login, module copy, target మీద Python execution, మరియు cleanup. సరైన ఫలితం వస్తే ప్రతి host కి ఒక green block కనిపిస్తుంది:

web1 | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false,
    "ping": "pong"
}

Green SUCCESS అంటే authentication, Python interpreter, మరియు transport అన్నీ సరిగ్గా పనిచేస్తున్నాయి — playbook కూడా పనిచేస్తుంది. Red UNREACHABLE! అంటే ఏ module రన్ అవ్వకముందే transport విఫలమైంది; దీనికి సంబంధించిన ఖచ్చితమైన error string మరియు పరిష్కారం కింద ఉన్న failure modes విభాగంలో ఉన్నాయి. తెలుసుకోవలసిన మరికొన్ని ad-hoc commands:

ansible all -a "uptime"
ansible all -m apt -a "update_cache=true upgrade=dist" --become

Ad-hoc అనేది ఒకసారి మాత్రమే చేసే పనులకు మరియు తనిఖీలకు (checks) ఉపయోగపడుతుంది. మీరు రెండుసార్లు రన్ చేయాలనుకునే ఏ పనైనా playbook లో ఉండాలి.

Step 5: మొదటి playbook — new-VPS checklist as code

కొత్త సర్వర్‌లో మొదటి పది నిమిషాల్లో మీరు మాన్యువల్‌గా చేసే పనులన్నీ ఇక్కడ ఉన్నాయి. దీనిని site.yml గా సేవ్ చేయండి:

---
- name: Baseline a fresh Ubuntu VPS
  hosts: vps
  become: true

  vars:
    deploy_user: deploy
    deploy_pubkey: "{{ lookup('file', '~/.ssh/id_ed25519.pub') }}"
    baseline_packages:
      - fail2ban
      - unattended-upgrades
      - ufw
    baseline_services:
      - fail2ban
      - unattended-upgrades

  tasks:
    - name: Create the deploy user
      ansible.builtin.user:
        name: "{{ deploy_user }}"
        groups: sudo
        append: true
        shell: /bin/bash

    - name: Install the deploy user's SSH key
      ansible.posix.authorized_key:
        user: "{{ deploy_user }}"
        key: "{{ deploy_pubkey }}"

    - name: Passwordless sudo for the deploy user
      ansible.builtin.copy:
        dest: /etc/sudoers.d/deploy
        content: "{{ deploy_user }} ALL=(ALL) NOPASSWD:ALL\n"
        mode: "0440"
        validate: /usr/sbin/visudo -cf %s

    - name: Install baseline packages
      ansible.builtin.apt:
        name: "{{ baseline_packages }}"
        state: present
        update_cache: true

    - name: Enable and start baseline services
      ansible.builtin.service:
        name: "{{ item }}"
        state: started
        enabled: true
      loop: "{{ baseline_services }}"

    - name: Harden sshd with a drop-in
      ansible.builtin.copy:
        dest: /etc/ssh/sshd_config.d/00-hardening.conf
        content: |
          PasswordAuthentication no
          KbdInteractiveAuthentication no
          PermitRootLogin prohibit-password
          X11Forwarding no
        mode: "0644"
        validate: /usr/sbin/sshd -t -f %s
      notify: Restart ssh

    - name: Allow OpenSSH through ufw
      community.general.ufw:
        rule: allow
        name: OpenSSH

    - name: Enable ufw with default deny
      community.general.ufw:
        state: enabled
        policy: deny

  handlers:
    - name: Restart ssh
      ansible.builtin.service:
        name: ssh
        state: restarted

కాపీ చేయడం కంటే ఈ క్రింది అంశాలను అర్థం చేసుకోవడం ముఖ్యం:

Variables అనేవి vars: కింద ఉంటాయి మరియు "{{ deploy_user }}" తో రిఫరెన్స్ చేయబడతాయి — ఒక విలువ బ్రేస్ (brace) తో ప్రారంభమైతే, పూర్తి ఎక్స్‌ప్రెషన్‌ను కోట్స్ (quote) లో ఉంచండి, లేకపోతే YAML పార్సర్ దానిని తప్పుగా చదువుతుంది. lookup('file', ...) రన్‌టైమ్‌లో control మెషీన్ నుండి మీ పబ్లిక్ కీని చదువుతుంది, కాబట్టి playbook లో ఎటువంటి కీ మెటీరియల్ ఉండదు.

The loop. loop: "{{ baseline_services }}" ప్రతి ఐటెమ్ కోసం సర్వీస్ టాస్క్‌ను ఒకసారి రన్ చేస్తుంది, మరియు అవుట్‌పుట్‌లో ప్రతి ఐటెమ్ విడివిడిగా కనిపిస్తుంది. apt టాస్క్ మాత్రం ప్యాకేజీ జాబితాను మొత్తంగా తీసుకుంటుందని గమనించండి — ఒకే apt ట్రాన్సాక్షన్ వేగంగా ఉంటుంది మరియు ప్యాకేజీల కోసం ఇది ఉత్తమ పద్ధతి; లూప్‌లు కేవలం ఒక సమయంలో ఒకే వస్తువుపై పనిచేసే మాడ్యూల్స్ కోసం మాత్రమే వాడాలి.

The handler అనేది అర్థం చేసుకోవలసిన ముఖ్యమైన కాన్సెప్ట్. notify: Restart ssh అంటే "వెంటనే ssh restart చేయి" అని కాదు. ఇది హ్యాండ్లర్‌ను క్యూ (queue) చేస్తుంది, ఇది ప్లే చివరలో మరియు నోటిఫై చేసే టాస్క్ changed ని రిపోర్ట్ చేస్తే మాత్రమే రన్ అవుతుంది. రేపు ఈ playbook ని మళ్ళీ రన్ చేయండి: డ్రాప్-ఇన్ ఫైల్ ఇప్పటికే సరిగ్గా ఉంటుంది, కాపీ టాస్క్ ok ని రిపోర్ట్ చేస్తుంది, మరియు sshd రీస్టార్ట్ అవ్వదు. validate: లైన్ ఒక భద్రతా కవచం — పాత ఫైల్‌ను రీప్లేస్ చేసే ముందు sshd ఫైల్‌ను తనిఖీ చేస్తుంది, కాబట్టి టైపో (typo) ఉంటే టాస్క్ ఫెయిల్ అవుతుంది కానీ డెమోన్ (daemon) విచ్ఛిన్నం కాదు.

PermitRootLogin prohibit-password, no కాదు — కావాలని ఇలా చేయబడింది. ఈ playbook కీ ద్వారా root గా లాగిన్ అవుతుంది. prohibit-password మీ కీని అనుమతిస్తూనే, పాస్‌వర్డ్ ద్వారా root లాగిన్‌లను నిలిపివేస్తుంది. డెప్లాయ్ యూజర్ సరిగ్గా పనిచేస్తున్నట్లు నిర్ధారణ అయిన తర్వాత (ssh deploy@10.0.0.10 sudo true — సాదా అడ్రస్, ఎందుకంటే web1 అనేది Ansible కి మాత్రమే తెలిసిన అలయాస్), ఇన్వెంటరీలో ansible_user=deploy ని మార్చండి మరియు తదుపరి రన్‌లో దానిని no కి మార్చండి. మిమ్మల్ని మీరు సర్వర్‌లో లాక్ చేసుకోకుండా, క్రమ పద్ధతిలో హార్డెన్ (harden) చేయండి.

00- ప్రిఫిక్స్ ముఖ్యం. చాలా కీవర్డ్స్ కోసం sshd అది మొదట చదివే అంశాన్ని అంగీకరిస్తుంది, మరియు Ubuntu యొక్క sshd_config లో దాని బాడీ కంటే ముందు లెక్సికల్ ఆర్డర్‌లో sshd_config.d/*.conf ఉంటుంది. Ubuntu 24.04 క్లౌడ్ ఇమేజ్‌లలో ఇప్పటికే ఆ డైరెక్టరీలో 60-cloudimg-settings.conf ఉంటుంది, మరియు cloud-init ద్వారా పాస్‌వర్డ్ లాగిన్‌లను ఎనేబుల్ చేసే ప్రొవైడర్లు PasswordAuthentication yes తో 50-cloud-init.conf ని జోడిస్తారు; మనది 00-hardening.conf గా పేరు పెట్టడం వల్ల అది మొదటగా అమరి రెండింటినీ అధిగమిస్తుంది.

Task order అనేది ఫైర్‌వాల్ భద్రత. Enable ufw కి ముందు డినై పాలసీతో Allow OpenSSH రన్ అవుతుంది — Ansible టాస్క్‌లను జాబితాలో ఉన్న క్రమంలోనే ఖచ్చితంగా అమలు చేస్తుంది, కాబట్టి గోడ నిర్మించక ముందే ఆ రంధ్రం (hole) ఏర్పడుతుంది. fail2ban ఉపయోగపడటానికి ఎటువంటి కాన్ఫిగరేషన్ అవసరం లేదు; దాని Ubuntu డిఫాల్ట్స్ నేరుగా sshd ని పర్యవేక్షిస్తాయి, మరియు జైల్స్ (jails) वास्तव में ఏమి చేస్తాయి — మరియు దేనిని ట్యూన్ చేయాలి — అనే అంశం fail2ban on Ubuntu 24.04 guide లో వివరించబడింది.

Step 6: --check ఉపయోగించి dry run చేయండి, ఆపై నిజంగా రన్ చేయండి

ansible-playbook site.yml --check

Check mode కనెక్ట్ అవుతుంది, అది ఏమి చేయబోతుందో లెక్కిస్తుంది, మరియు ఏదీ మార్చదు. కింద ఉన్న PLAY RECAP లో changed= కౌంట్‌ను చూడండి — ప్రతి host ను మార్చే పనుల సంఖ్య ఇది. ఒక ముఖ్యమైన విషయం: ఒక పనుల క్రమం (sequence) మునుపటి పనిపై ఆధారపడి ఉంటే, check mode లో పరిమితులు ఉంటాయి. Ubuntu యొక్క standard server image లో ufw ముందే ఉంటుంది, కాబట్టి ఈ playbook dry-run విజయవంతంగా పూర్తవుతుంది — కానీ ufw లేని minimal image ఉపయోగిస్తే, check mode లో ufw పనులు fail అవుతాయి. ఎందుకంటే check mode ప్యాకేజీని ఇన్‌స్టాల్ చేయదు, కాబట్టి module కి పిలవడానికి ఏదీ ఉండదు. ఇది dry run యొక్క పరిమితి మాత్రమే, మీ playbook లోని bug కాదు. ప్లాన్ సరిగ్గా ఉన్నప్పుడు:

ansible-playbook site.yml

ప్రతి task ప్రతి host కోసం ఒక లైన్ ప్రింట్ చేస్తుంది — పసుపు రంగు changed, ఆకుపచ్చ రంగు ok — మరియు recap ఈ విధంగా ఉండాలి:

PLAY RECAP *********************************************************************
web1 : ok=10  changed=9  unreachable=0  failed=0  skipped=0  rescued=0  ignored=0
web2 : ok=10  changed=9  unreachable=0  failed=0  skipped=0  rescued=0  ignored=0

పది ok అంటే fact-gathering ప్లస్ ఎనిమిది tasks ప్లస్ handler. మీ changed నా దాని కంటే ఒకటి లేదా రెండు తేడాగా ఉండవచ్చు: Ubuntu standard image లో ufw మరియు unattended-upgrades ముందే ఉంటాయి, మరియు apt ఇన్‌స్టాల్ చేసిన వెంటనే fail2ban స్వయంచాలకంగా ప్రారంభమవుతుంది, కాబట్టి ఒక task దాని మొదటి రన్ లోనే ok ని రిపోర్ట్ చేయవచ్చు — అంటే ఆ state ఇప్పటికే ఉంది అని అర్థం. unreachable మరియు failed విలువలు తప్పనిసరిగా సున్నా ఉండాలి. become: true గురించి ఒక గమనిక: మీరు root గా కనెక్ట్ అయినప్పుడు ఇది కేవలం ఒక औपचारिकता (formality) మాత్రమే, కానీ మీరు ansible_user ని deploy గా మార్చిన వెంటనే, sudo నిజంగా పనిచేస్తుంది — మరియు ఈ playbook ఇన్‌స్టాల్ చేసే NOPASSWD sudoers ఫైల్ వల్లనే -K మీ command line లో కనిపించదు. అది లేకపోతే మీకు Missing sudo password వస్తుంది, దీని గురించి కింద వివరించబడింది.

Step 7: run it twice — what idempotence looks like

వెంటనే అదే కమాండ్‌ను మళ్ళీ రన్ చేయండి:

web1 : ok=9  changed=0  unreachable=0  failed=0  skipped=0  rescued=0  ignored=0

changed=0 మరియు ok విలువలు ఒకటి తగ్గాయి, ఎందుకంటే నోటిఫై చేయని హ్యాండ్లర్ రన్ కాలేదు. ఏదీ రీఇన్‌స్టాల్ చేయబడలేదు, sshd రీస్టార్ట్ చేయబడలేదు, ufw మార్చబడలేదు. దీనివల్ల ఈ ప్లేబుక్ ఒక provisioner లాగే ఒక audit లాగా కూడా పనిచేస్తుంది: వచ్చే నెలలో ఇన్వెంటరీకి web3 జోడించి మళ్ళీ రన్ చేయండి — కొత్త బాక్స్ బిల్డ్ అవుతుంది, పాత బాక్స్‌లు వెరిఫై చేయబడతాయి. మీరు తాకని బాక్స్‌లో nonzero changed ఉంటే అది drift అని అర్థం; ప్లేబుక్‌లో ఎడిట్ చేయాల్సిన దానిని ఎవరో మాన్యువల్‌గా ఎడిట్ చేశారని ఇది మీకు తెలియజేస్తుంది.

ఇక్కడి నుండి ఈ పద్ధతి మరింత విస్తరిస్తుంది. తదుపరి ప్లేబుక్ WireGuard VPN on the same VPS ని సెటప్ చేస్తుంది మరియు SSH కేవలం టన్నెల్ ద్వారా మాత్రమే స్పందించేలా ufw రూల్‌ను కఠినతరం చేస్తుంది; ఆ తర్వాత, ప్రతి యాప్ సర్వర్‌లో Docker and Compose ఇన్‌స్టాల్ చేసే ప్లేబుక్ వస్తుంది. site.yml మూడు స్క్రీన్‌ల కంటే ఎక్కువ పొడవు వస్తే, దానిని roles గా విభజించండి — కానీ అంతకంటే ముందు కాదు.

Failure modes, with the strings you will see

UNREACHABLE with Permission denied.

web1 | UNREACHABLE! => {
    "changed": false,
    "msg": "Failed to connect to the host via ssh: root@10.0.0.10: Permission denied (publickey).",
    "unreachable": true
}

ఏ module రన్ అవ్వకముందే SSH transport విఫలమైంది: ansible_user తప్పుగా ఉంది, key ఆ host కి కాపీ చేయబడలేదు, లేదా తప్పు key ఉపయోగించబడుతోంది. దీనిని plain ssh root@10.0.0.10 తో, ఆపై ssh -v తో రన్ చేసి ఏ keys offered అయ్యాయో చూడండి. ఒకవేళ password SSH పనిచేసి, Ansible పనిచేయకపోతే, మీరు ssh-copy-id ని వదిలేసి ఉన్నారని అర్థం.

Missing sudo password.

web1 | FAILED! => {
    "msg": "Missing sudo password"
}

మీరు become: true ని సెట్ చేశారు, non-root user గా కనెక్ట్ అయ్యారు, మరియు ఆ user కి sudo కోసం password అవసరం. కమాండ్ లైన్ లో -K (--ask-become-pass) ని జోడించండి, లేదా ఆ user కి NOPASSWD sudoers entry ఇవ్వండి — అందుకే మీరు ఆ user కి మారకముందే, playbook ద్వారా deploy కోసం ఒక entry ఇన్‌స్టాల్ చేయబడుతుంది.

error: externally-managed-environment. మీరు Ubuntu 24.04 లోని system Python పై pip ని రన్ చేశారు. దీని గురించి step 1 లో వివరించబడింది: pipx వాడాలి, pip కాదు, మరియు --break-system-packages కాదు.

mapping values are not allowed in this context.

ERROR! Syntax Error while loading YAML.
  mapping values are not allowed in this context

ఇది దాదాపు ఎప్పుడూ indentation వల్లే జరుగుతుంది: key తప్పు depth లో ఉండటం, లేదా colon తర్వాత space లేకపోవడం. రిపోర్ట్ చేయబడిన line number తప్పు జరిగిన చోటుకు దగ్గరగా ఉంటుంది, సరిగ్గా అక్కడే ఉండదు — పైన ఉన్న line ని కూడా తనిఖీ చేయండి. దీనికి సంబంధితమైన found character '\t' that cannot start any token అంటే tab వాడటం; YAML వాటిని అనుమతించదు. ప్రతి run కి ముందు ansible-playbook site.yml --syntax-check చేయడం అలవాటు చేసుకోండి, మరియు మీ editor లో YAML కోసం two-space indentation సెట్ చేయండి.

/usr/bin/python3: not found. standard Ubuntu 24.04 images లలో ఇది అరుదు, కానీ minimal లేదా netboot images లలో ఇది సాధారణం: target లో Python లేకపోవడం వల్ల module execution విఫలమవుతుంది. దీనిని raw module తో bootstrap చేయండి, ఇది target లో ఏదీ అవసరం లేని ఏకైక module: ansible all -m raw -a "apt-get update && apt-get install -y python3" --become, ఆపై playbook ని మళ్ళీ రన్ చేయండి.

FAQ

Ansible ని అది నిర్వహించే సర్వర్‌లలో ఇన్‌స్టాల్ చేయాలా?

లేదు. Ansible అనేది agentless: కంట్రోల్ మెషీన్ SSH ద్వారా చిన్న Python modules ని పంపిస్తుంది, వాటిని రన్ చేస్తుంది, మరియు తొలగిస్తుంది. టార్గెట్ సర్వర్‌కు python3 మరియు SSH access మాత్రమే అవసరం, ఇవి స్టాక్ Ubuntu images లలో ఇప్పటికే ఉంటాయి. ఈ గైడ్‌లో మొత్తం ప్రక్రియలో కేవలం మీ కంట్రోల్ మెషీన్‌లో మాత్రమే ఇన్‌స్టాలేషన్ జరుగుతుంది.

Ansible "Permission denied (publickey)" అని ఎందుకు చెబుతోంది?

Permission denied (publickey) తో కూడిన UNREACHABLE! బ్లాక్ వల్ల, Ansible ఏదీ రన్ చేయకముందే SSH authentication విఫలమైందని అర్థం. inventory లోని ansible_user మీరు సెటప్ చేసిన అకౌంట్‌తో సరిపోలుతుందో లేదో చూడండి, మీరు ఆ host కి ssh-copy-id రన్ చేశారో లేదో తనిఖీ చేయండి, మరియు సాధారణ ssh user@host పాస్‌వర్డ్ లేకుండా లాగిన్ అవుతుందో లేదో చూడండి. సాధారణ ssh కమాండ్ దేనిని పరిష్కరిస్తే, Ansible కూడా అదే విధంగా పనిచేస్తుంది, ఎందుకంటే అవి ఒకే రకమైన transport ని ఉపయోగిస్తాయి.

Ansible లో idempotent అంటే ఏమిటి?

ఒక task చేయవలసిన పనిని (action) కాకుండా, కావలసిన స్థితిని (desired state) — అంటే "ఈ package ఉంది", "ఈ line ఈ file లో ఉంది" అని ప్రకటిస్తుంది. ఒకవేళ ఆ స్థితి ఇప్పటికే ఉంటే, Ansible ఏదీ చేయదు మరియు changed కి బదులుగా ok ని రిపోర్ట్ చేస్తుంది. అందుకే playbook ని రెండుసార్లు రన్ చేసినప్పుడు రెండోసారి changed=0 కనిపిస్తుంది, మరియు మళ్ళీ రన్ చేయడం అనేది రిస్క్ ఉన్న re-install కాకుండా సురక్షితమైన audit గా ఉంటుంది.

Ubuntu 24.04 లో Ansible ఇన్‌స్టాల్ చేయడానికి pip లేదా pipx ఉపయోగించాలా?

pipx ఉపయోగించండి. Ubuntu 24.04 సిస్టమ్ Python ని externally managed గా పరిగణిస్తుంది, కాబట్టి error: externally-managed-environment వల్ల pip install ansible డిజైన్ పరంగా విఫలమవుతుంది. pipx install --include-deps ansible Ansible ని ఒక isolated virtualenv లో ఉంచుతుంది మరియు ansible, ansible-playbook మరియు మిగిలిన వాటిని మీ PATH లో క్లీన్‌గా ఉంచుతుంది.

ansible మరియు ansible-core ప్యాకేజీల మధ్య తేడా ఏమిటి?

ansible-core అనేది engine మరియు కేవలం ansible.builtin modules మాత్రమే కలిగి ఉంటుంది. ansible ప్యాకేజీ core ని మరియు క్యూరేటెడ్ community collections ని కలిపి అందిస్తుంది — ఇందులో ఈ గైడ్‌లో ఉపయోగించే ansible.posix (authorized_key module) మరియు community.general (ufw module) కూడా ఉంటాయి. మొదట పూర్తి ప్యాకేజీతో ప్రారంభించండి; మీకు అవసరమైనప్పుడు మాత్రమే core మరియు ఎంచుకున్న collections కి పరిమితం చేయండి.

#ansible #automation #ubuntu#devops