Ubuntu 24.04లో Ansible మొదటి ప్లేబుక్ ఎలా రాయాలి

మీరు ఏమి నిర్మిస్తున్నారు

Ansible ఇన్‌స్టాల్ చేయబడిన ఒక కంట్రోల్ మెషీన్, మరియు కేవలం స్టాక్ ఇమేజ్ మాత్రమే ఉన్న ఒకటి లేదా అంతకంటే ఎక్కువ కొత్త Ubuntu 24.04 VPSలు. ఈ ప్రక్రియ ముగిసేసరికి, మీ సర్వర్ల పేర్లతో కూడిన ఒక inventory ఫైల్, ప్రామాణీకరణ (authentication) సక్రమంగా పనిచేస్తుందని నిరూపించే ad-hoc ping, మరియు కొత్త VPS కోసం అవసరమైన అన్ని పనులను కోడ్ రూపంలో చేసే ఒక playbook మీ వద్ద ఉంటాయి: మీ SSH కీతో ఒక deploy యూజర్, సురక్షితమైన sshd, fail2ban, unattended upgrades, మరియు మిగిలిన అన్నింటినీ నిరాకరించి కేవలం OpenSSHను మాత్రమే అనుమతించే ఫైర్‌వాల్. దీన్ని ఒక సర్వర్‌కు లేదా ఇరవై సర్వర్లకు వర్తింపజేయవచ్చు. దీన్ని రెండుసార్లు రన్ చేసినా, రెండోసారి ఏ మార్పులూ జరగవు; అదే దీని ముఖ్య ఉద్దేశ్యం.

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

Ansible అంటే ఏమిటో ఒకే పేరాలో

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

ముందస్తు అవసరాలు మరియు గమనించవలసిన ముఖ్య విషయాలు

• ఒక కంట్రోల్ మెషిన్: మీ ల్యాప్‌టాప్ లేదా చిన్న VPS. నేను Ubuntu 24.04 ఉపయోగిస్తున్నానని భావిస్తున్నాను; Homebrew ద్వారా pipx ఇన్‌స్టాల్ చేసిన తర్వాత macOS కూడా ఇదే విధంగా పనిచేస్తుంది.
• KVMపై Ubuntu 24.04 నడుస్తున్న ఒకటి లేదా అంతకంటే ఎక్కువ టార్గెట్ VPSలు, వీటిని root యూజర్‌గా యాక్సెస్ చేయగలగాలి. వీటిలో ఏమీ ఇన్‌స్టాల్ చేయబడదు.
• ప్రతి టార్గెట్‌కు SSH key అథెంటికేషన్ ఉండాలి. మీ ssh కమాండ్ ఎంతవరకు అథెంటికేట్ అవుతుందో, Ansible కూడా అంతే అథెంటికేట్ అవుతుంది. ఒకవేళ ssh root@host పాస్‌వర్డ్ అడిగితే, Ansible విఫలమవుతుంది.
• Ubuntu 24.04లో, pip install ansible అనేది error: externally-managed-environment తో విఫలమవుతుంది. ఇది డిస్ట్రో యొక్క ఉద్దేశపూర్వక విధానం, సాఫ్ట్‌వేర్ లోపం కాదు. pipx ఉపయోగించండి.
• YAMLలో వైట్‌స్పేస్ అనేది సింటాక్స్‌లో భాగం. తప్పు ఇండెంటేషన్ వల్ల mapping values are not allowed in this context వస్తుంది, మరియు ఎక్కడైనా ట్యాబ్ క్యారెక్టర్ ఉంటే అది ఫెయిల్‌కు దారితీస్తుంది.
• playbook ద్వారా sshd ని హార్డెన్ చేసేటప్పుడు, ప్రతి టార్గెట్‌పై ఒక SSH సెషన్‌ను తెరిచి ఉంచండి. నేను కస్టమర్‌లకు సహాయం చేసిన ప్రతి లాకౌట్ సమస్య, "క్లీన్ సెషన్ నుంచి పరీక్షించడానికి" చివరి సెషన్‌ను మూసివేయడం వల్లే జరిగింది.

దశ 1: కంట్రోల్ మెషీన్‌పై pipx తో Ansible ఇన్‌స్టాల్ చేయండి, pip తో కాదు

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

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 సిస్టమ్ Python ను externally managed (PEP 668) గా గుర్తిస్తుంది, కాబట్టి ఒకే ఫైళ్ల కోసం pip మరియు apt పోటీ పడకూడదు. --break-system-packages వాడకండి; ఆ ఫ్లాగ్ పేరులోనే దాని ఉద్దేశ్యం ఉంది. దీనికి సరైన పరిష్కారం pipx, ఇది Ansible కు ప్రత్యేకమైన virtualenv ను కేటాయించి, బైనరీలను మీ PATH లో ఉంచుతుంది:

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

pipx ensurepath తర్వాత కొత్త షెల్ ఓపెన్ చేయండి, అప్పుడే PATH మార్పులు అమలవుతాయి. --include-deps అనేది అలంకారం కోసం కాదు: ansible ప్యాకేజీ సొంతంగా ఎటువంటి కన్సోల్ స్క్రిప్ట్‌లను కలిగి ఉండదు, ansible, ansible-playbook, మరియు మిగిలినవి దాని ansible-core డిపెండెన్సీ యొక్క ఎంట్రీ పాయింట్లు, కాబట్టి ఆ ఫ్లాగ్ లేకుండా pipx ఇన్‌స్టాల్ చేయడానికి నిరాకరించి No apps associated with package ansible or its dependencies అని చూపిస్తుంది. అలాగే కేవలం ansible-core కాకుండా ansible ప్యాకేజీని ఇన్‌స్టాల్ చేయండి, పూర్తి ప్యాకేజీ కమ్యూనిటీ కలెక్షన్‌లను కలిగి ఉంటుంది, మరియు ఈ ప్లేబుక్ వాటిలో రెండింటిని (ansible.posix మరియు community.general) ఉపయోగిస్తుంది.

ansible --version

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

ఇన్‌స్టాలేషన్ ఇంతే. టార్గెట్ మెషీన్‌లలో ఏమీ ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు.

దశ 2: ప్రతి target కు SSH key యాక్సెస్

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

ఈ ఒక్క లైన్ రెండు పనులను చేస్తుంది: ఇది పాస్‌వర్డ్ లేకుండా key authentication పనిచేస్తుందని నిర్ధారిస్తుంది మరియు host key ని known_hosts లో నమోదు చేస్తుంది. దీన్ని ఇప్పుడే చేయండి, ఎందుకంటే Ansible లో నమోదు చేయని host key కనిపిస్తే, అది రన్ అవుతున్న మధ్యలో ఇంటరాక్టివ్ ప్రాంప్ట్‌ను అడుగుతుంది. ఇది సర్వర్ హ్యాంగ్ అయినట్లుగా అనిపిస్తుంది.

దశ 3: ఇన్వెంటరీ, మొదట INI, పెరిగినప్పుడు YAML

Ansible నియంత్రించగల మెషీన్ల జాబితాను కలిగి ఉన్న టెక్స్ట్ ఫైల్ ఇన్వెంటరీ. ఒక కొత్త ప్రాజెక్ట్ డైరెక్టరీలో inventory.iniని సృష్టించండి:

[vps]
web1 ansible_host=10.0.0.10
web2 ansible_host=10.0.0.20

[vps:vars]
ansible_user=root

web1 అనేది మీరు ఎంచుకున్న అలియాస్ (alias), ఇది అవుట్‌పుట్‌లో కనిపిస్తుంది మరియు మీరు --limit web1తో దేనిని లక్ష్యంగా చేసుకుంటారో అదే. ansible_host అనేది అసలైన చిరునామా. [vps] అనేది ఒక గ్రూప్, మరియు [vps:vars] ఆ గ్రూప్‌లోని ప్రతి హోస్ట్‌కు వేరియబుల్స్‌ను సెట్ చేస్తుంది; ansible_user అనేది Ansible ఏ యూజర్‌గా లాగిన్ అవ్వాలో తెలియజేస్తుంది. దాని పక్కనే, ఒక ansible.cfgని ఉంచండి, తద్వారా మీరు మళ్ళీ ఎప్పుడూ -iని టైప్ చేయాల్సిన అవసరం ఉండదు:

[defaults]
inventory = inventory.ini

Ansible ప్రస్తుత డైరెక్టరీ నుండి ansible.cfgని చదువుతుంది. అదే ఇన్వెంటరీని YAML ఫార్మాట్‌లో, inventory.ymlగా సేవ్ చేసి, ansible.cfgని ఆ పేరుకు పాయింట్ చేయండి. హోస్ట్‌లకు ఒక్కొక్కదానికి అనేక వేరియబుల్స్ ఉన్నప్పుడు మీరు దీనినే ఇష్టపడతారు:

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

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

దశ 4: అడ్-హాక్ కమాండ్లు, అన్నీ సక్రమంగా ఉన్నాయని తెలిపే గ్రీన్ పాంగ్

ansible all -m ping

ఇది ICMP కాదు. ping మాడ్యూల్ అనేది పూర్తి స్థాయి రిహార్సల్: SSH లాగిన్, మాడ్యూల్ కాపీ, టార్గెట్ సర్వర్‌పై Python ఎగ్జిక్యూషన్, మరియు క్లీనప్. సరైన ఫలితం ఆకుపచ్చ రంగులో, ప్రతి హోస్ట్‌కు ఒక బ్లాక్ చొప్పున కనిపిస్తుంది:

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

ఆకుపచ్చ రంగులో ఉన్న SUCCESS అంటే అథెంటికేషన్, Python ఇంటర్‌ప్రెటర్, మరియు ట్రాన్స్‌పోర్ట్ అన్నీ సక్రమంగా పనిచేస్తున్నాయని అర్థం, కాబట్టి ప్లేబుక్ కూడా పనిచేస్తుంది. ఎరుపు రంగులో ఉన్న UNREACHABLE! అంటే ఏ మాడ్యూల్ రన్ అవ్వకముందే ట్రాన్స్‌పోర్ట్ విఫలమైందని అర్థం; దీనికి సంబంధించిన ఖచ్చితమైన వివరాలు మరియు పరిష్కారాలు కింద ఉన్న ఫెయిల్యూర్ మోడ్స్ విభాగంలో ఉన్నాయి. తెలుసుకోవలసిన మరో రెండు అడ్-హాక్ కమాండ్లు ఇక్కడ ఉన్నాయి:

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

అడ్-హాక్ కమాండ్లు కేవలం ఒకసారి చేసే పనులకు మరియు తనిఖీలకు మాత్రమే. మీరు ఏదైనా పనిని రెండుసార్లు చేయాల్సి వస్తే, దానిని ప్లేబుక్‌లో చేర్చాలి.

దశ 5: మొదటి ప్లేబుక్, కొత్త-VPS చెక్‌లిస్ట్ కోడ్‌గా

కొత్త సర్వర్‌లో మొదటి పది నిమిషాల్లో మీరు మాన్యువల్‌గా చేసే పనులన్నీ ఇక్కడ ఉన్నాయి. దీన్ని 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 }}" తో సూచించబడతాయి. ఒక విలువ బ్రేస్‌తో ప్రారంభమైతే మొత్తం ఎక్స్‌ప్రెషన్‌ను కోట్స్ (quotes) లో ఉంచండి, లేకపోతే YAML పార్సర్ దాన్ని తప్పుగా అర్థం చేసుకుంటుంది. lookup('file', ...) రన్‌టైమ్‌లో మీ control మెషీన్ నుండి పబ్లిక్ కీని చదువుతుంది, కాబట్టి ప్లేబుక్‌లో ఎటువంటి కీ మెటీరియల్ ఉండదు.

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

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

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

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 అని పేరు పెట్టడం వల్ల అది మొదట క్రమబద్ధీకరించబడి, మిగిలిన వాటి కంటే ప్రాధాన్యత పొందుతుంది.

టాస్క్ క్రమం ఫైర్‌వాల్ భద్రతకు కీలకం. Allow OpenSSH అనేది deny పాలసీతో Enable ufw కంటే ముందు రన్ అవుతుంది. Ansible టాస్క్‌లను జాబితా చేసిన క్రమంలోనే ఖచ్చితంగా అమలు చేస్తుంది, కాబట్టి గోడ కట్టకముందే రంధ్రం ఉంటుంది. fail2ban ఇక్కడ ఉపయోగపడటానికి ఎటువంటి కాన్ఫిగరేషన్ అవసరం లేదు; దీని Ubuntu డిఫాల్ట్‌లు sshd ని పర్యవేక్షిస్తాయి. జైల్స్ ఏమి చేస్తాయి మరియు దేనిని ట్యూన్ చేయాలి అనేది fail2ban on Ubuntu 24.04 గైడ్ లో వివరించబడింది.

దశ 6: --check ఫ్లాగ్‌తో డ్రై రన్ చేయడం, ఆపై అసలైన రన్ చేయడం

ansible-playbook site.yml --check

Check మోడ్ కనెక్ట్ అయ్యి, తాను ఏమి చేస్తుందో లెక్కిస్తుంది, కానీ దేనినీ మార్చదు. చివరలో ఉన్న PLAY RECAP లోని changed= గణనను చూడండి; ఇది ప్రతి హోస్ట్‌లో మార్పులు చేసే పనుల సంఖ్య. ఒక ముఖ్యమైన విషయం: మునుపటి టాస్క్ మార్పులపై తర్వాతి టాస్క్ ఆధారపడి ఉన్నప్పుడు, check మోడ్‌కు కొన్ని పరిమితులు ఉంటాయి. Ubuntu స్టాండర్డ్ సర్వర్ ఇమేజ్‌లో ufw ముందుగానే ఉంటుంది, కాబట్టి ఈ playbook డ్రై రన్ సజావుగా సాగుతుంది. కానీ, అది లేని minimal ఇమేజ్‌లో, check మోడ్‌లో ufw టాస్క్‌లు fail అవుతాయి. ఎందుకంటే, check మోడ్ ప్యాకేజీని ఇన్‌స్టాల్ చేయదు, కాబట్టి ఆ మాడ్యూల్‌కు కాల్ చేయడానికి ఏమీ ఉండదు. ఇది మీ playbook లోని లోపం కాదు, డ్రై రన్ యొక్క పరిమితి మాత్రమే. ప్లాన్ సరిగ్గా ఉందని నిర్ధారించుకున్నాక:

ansible-playbook site.yml

ప్రతి టాస్క్ ప్రతి హోస్ట్‌కు ఒక లైన్‌ను ప్రింట్ చేస్తుంది, పసుపు రంగులో changed, ఆకుపచ్చ రంగులో ok కనిపిస్తాయి, మరియు రీక్యాప్ ఇలా ఉండాలి:

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, ఎనిమిది టాస్క్‌లు మరియు హ్యాండ్లర్. మీ changed నా గణాంకాల కంటే ఒకటి లేదా రెండు తేడా ఉండవచ్చు: Ubuntu స్టాండర్డ్ ఇమేజ్‌లో ufw మరియు unattended-upgrades ముందుగానే ఉంటాయి. అలాగే, apt ఇన్‌స్టాల్ చేసిన వెంటనే fail2ban తనంతట తానుగా ప్రారంభమవుతుంది, కాబట్టి ఒక టాస్క్ మొదటి రన్‌లోనే ok అని రిపోర్ట్ చేయవచ్చు, అంటే అది కోరిన స్థితి అప్పటికే అక్కడ ఉంది. ఖచ్చితంగా సున్నా ఉండాల్సినవి unreachable మరియు failed. become: true గురించి ఒక గమనిక: మీరు root గా కనెక్ట్ అయినప్పుడు ఇది కేవలం ఒక ఫార్మాలిటీ మాత్రమే. కానీ మీరు ansible_user ను deploy కి మార్చిన క్షణం నుండి, sudo నిజంగా పనిచేస్తుంది. ఈ playbook ఇన్‌స్టాల్ చేసే NOPASSWD sudoers ఫైల్, మీ కమాండ్ లైన్ నుండి -K ను దూరంగా ఉంచుతుంది. అది లేకపోతే మీకు Missing sudo password వస్తుంది, దీని గురించి కింద వివరించబడింది.

దశ 7: రెండుసార్లు రన్ చేయడం, ఐడెంపోటెన్స్ (idempotence) ఎలా ఉంటుందో చూడండి

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

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

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

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

వైఫల్య రీతులు మరియు మీరు చూసే సందేశాలు

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
}

ఏదైనా మాడ్యూల్ రన్ అవ్వకముందే SSH ట్రాన్స్‌పోర్ట్ విఫలమైంది: ansible_user తప్పుగా ఉంది, కీని ఆ హోస్ట్‌కు కాపీ చేయలేదు, లేదా తప్పు కీని ఉపయోగిస్తున్నారు. సాధారణ ssh root@10.0.0.10 తో దీన్ని పునరావృతం చేయండి, ఆపై ఏ కీలు ఆఫర్ చేయబడ్డాయో చూడటానికి ssh -v వాడండి. పాస్‌వర్డ్ SSH పనిచేస్తూ Ansible పనిచేయకపోతే, మీరు ssh-copy-id ని విస్మరించారని అర్థం.

Missing sudo password.

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

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

error: externally-managed-environment. మీరు Ubuntu 24.04 లోని సిస్టమ్ Python పై pip రన్ చేశారు. ఇది మొదటి దశలోనే కవర్ చేయబడింది: pip వాడకండి, pipx వాడండి, మరియు --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

ఇది దాదాపు ఎప్పుడూ ఇండెంటేషన్ సమస్యే: కీ తప్పు స్థాయిలో ఉండటం, లేదా కోలన్ తర్వాత స్పేస్ లేకపోవడం. చూపించిన లైన్ నంబర్ తప్పు ఉన్న చోటికి దగ్గరగా ఉంటుంది, ఖచ్చితంగా అదే లైన్ కాదు, కాబట్టి పైన ఉన్న లైన్‌ను కూడా తనిఖీ చేయండి. దీనికి సంబంధించిన found character '\t' that cannot start any token అంటే ఎక్కడో ఒక ట్యాబ్ (tab) వచ్చిందని అర్థం; YAML లో ట్యాబ్‌లు అనుమతించబడవు. ప్రతి రన్‌కు ముందు ansible-playbook site.yml --syntax-check ని అలవాటు చేసుకోండి, మరియు మీ ఎడిటర్‌ను YAML కోసం రెండు-స్పేస్‌ల ఇండెంటేషన్‌కు సెట్ చేయండి.

/usr/bin/python3: not found. సాధారణ Ubuntu 24.04 ఇమేజ్‌లలో ఇది అరుదు, కానీ మినిమల్ లేదా నెట్‌బూట్ ఇమేజ్‌లలో సాధారణం: టార్గెట్ సిస్టమ్‌లో Python లేకపోవడం వల్ల మాడ్యూల్ ఎగ్జిక్యూషన్ విఫలమవుతుంది. దీన్ని raw మాడ్యూల్‌తో బూట్‌స్ట్రాప్ చేయండి, ఇది అవతలి వైపు ఏమీ లేకపోయినా పనిచేసే ఏకైక మాడ్యూల్: ansible all -m raw -a "apt-get update && apt-get install -y python3" --become, ఆపై ప్లేబుక్‌ను మళ్ళీ రన్ చేయండి.

FAQ

నేను మేనేజ్ చేసే సర్వర్లలో Ansible ఇన్‌స్టాల్ చేయాలా?

అవసరం లేదు. Ansible ఏజెంట్-రహితమైనది: కంట్రోల్ మెషీన్ చిన్న Python మాడ్యూళ్లను SSH ద్వారా పంపి, వాటిని రన్ చేసి, ఆపై తొలగిస్తుంది. టార్గెట్ సర్వర్‌లో కేవలం python3 మరియు SSH యాక్సెస్ ఉంటే సరిపోతుంది, ఇవి సాధారణంగా అన్ని Ubuntu ఇమేజ్‌లలో ఇప్పటికే ఉంటాయి. ఈ గైడ్‌లో ఇన్‌స్టాలేషన్ ప్రక్రియ మొత్తం మీ కంట్రోల్ మెషీన్‌పై మాత్రమే జరుగుతుంది.

Ansible ఎందుకు "Permission denied (publickey)" అని చూపిస్తుంది?

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

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

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

Ubuntu 24.04లో Ansible ఇన్‌స్టాల్ చేయడానికి pip వాడాలా లేక pipx వాడాలా?

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

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

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