Ansible ile yeni bir kullanıcı ve şifre oluşturmak

Ubuntu 12.04'te yeni bir kullanıcı oluşturan yanıtlanabilir bir görevim var;

- name: Add deployment user
    action: user name=deployer password=mypassword

beklendiği gibi tamamlanıyor ama o kullanıcı olarak oturum açıp şifre ile sudo yapmaya çalıştığımda her zaman yanlış olduğunu söylüyor. Neyi yanlış yapıyorum?

Ansible'ın usermodül kılavuzunu okursanız , parametrenin nasıl kullanılacağıyla ilgili ayrıntılar için sizi Ansible- samples github deposuna yönlendirecektir .password

Orada şifrenizin karma hale getirilmesi gerektiğini göreceksiniz.

- hosts: all
  user: root
  vars:
    # created with:
    # python -c 'import crypt; print crypt.crypt("This is my Password", "$1$SomeSalt$")'
    password: $1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI.

  tasks:
    - user: name=tset password={{password}}

Başucu kitabınızda veya yanıtlanabilir komut satırınızda şifreniz olduğu gibi düz metin olarak bulunuyorsa, bu, gölge dosyanıza kaydedilen şifre karmasının yanlış olduğu anlamına gelir . Bu, şifrenizle kimlik doğrulamaya çalıştığınızda, hash değerinin asla eşleşmeyeceği anlamına gelir.

Ayrıca, parola parametresinin bazı nüansları ve nasıl doğru şekilde kullanılacağı ile ilgili Ansible SSS bölümüne bakın .

Bunu yanıtlamak için çok geç kalmış olabilirim ama son zamanlarda jinja2 filtrelerinin şifrelenmiş parolaların üretimini idare etme kapasitesine sahip olduğunu anladım. Benim içinde main.ymlben şifreli şifreyi olarak üreten ediyorum:

- name: Creating user "{{ uusername }}" with admin access
  user: 
    name: {{ uusername }}
    password: {{ upassword | password_hash('sha512') }}
    groups: admin append=yes
  when:  assigned_role  == "yes"

- name: Creating users "{{ uusername }}" without admin access
  user:
    name: {{ uusername }}
    password: {{ upassword | password_hash('sha512') }}
  when:  assigned_role == "no"

- name: Expiring password for user "{{ uusername }}"
  shell: chage -d 0 "{{ uusername }}"

"uusername" ve "upassword" başucu kitabına göre aktarılıyor --extra-varsve burada geçirilen şifreyi şifrelemek için jinja2 filtresini kullandığımı fark ettim.

Bununla ilgili aşağıdaki öğreticiyi bloguma ekledim

• https://thinkingmonster.wordpress.com/it-automation/386-2/ansible-roles/

Başka bir çözüm önermek istiyorum:

- name: Create madhead user
  user:
    name: madhead
    password: "{{ 'password' | password_hash('sha512') }}"
    shell: /bin/zsh
    update_password: on_create
  register: madhead
- name: Force madhead to change password
  shell: chage -d 0 madhead
  when: madhead.changed

Neden daha iyi? Burada daha önce belirtildiği gibi Ansible oyunları idempotent olmalıdır. Bunları emir niteliğindeki bir eylemler dizisi olarak değil, istenen bir durum, bildirim tarzı gibi düşünmelisiniz. Sonuç olarak, onu birden çok kez çalıştırabilmeli ve aynı sonucu, aynı sunucu durumunu alabilmelisiniz.

Bunların hepsi kulağa harika geliyor ama bazı nüanslar var. Bunlardan biri kullanıcıları yönetmek. "İstenen durum", bir kullanıcı oluşturan bir oyunu her çalıştırdığınızda, kullanıcının tam olarak bu duruma uyacak şekilde güncelleneceği anlamına gelir. "Güncellenmiş" derken şifresinin de değişeceğini kastediyorum. Ama büyük ihtimalle ihtiyacın olan şey bu değil. Genellikle, kullanıcı oluşturmanız, şifresini yalnızca bir kez ayarlamanız ve sonlandırmanız gerekir, daha fazla oynatma işlemi şifresini güncellememelidir.

Neyse ki, Ansible modülünde bu sorunu çözen bir update_passwordöznitelik var . Bunu kayıtlı değişkenlerle karıştırarak , şifresini yalnızca kullanıcı gerçekten güncellendiğinde sona erdirebilirsiniz.user

Kullanıcının kabuğunu manuel olarak değiştirirseniz (farz edin, kötü yöneticinin oyunda zorladığı kabuğu beğenmezsiniz), kullanıcı güncellenecek ve bu nedenle şifresinin süresi dolacaktır.

Ayrıca oyunlarda düz metin ilk şifrelerini nasıl kolayca kullanabileceğinizi unutmayın. Bunları başka bir yerde kodlamanıza ve hash'leri yapıştırmanıza gerek yok, bunun için Jinja2 filtresini kullanabilirsiniz . Ancak, sizden önce birisi oturum açarsa bu bir güvenlik açığı olabilir.

Ansible 'kullanıcı' modülü, kullanıcıları idempotent bir şekilde yönetir . Aşağıdaki başucu kitabında, ilk görev durum = kullanıcı için mevcut olduğunu belirtir . İlk eylemdeki ' register: newuser ', ikinci eylemin, kullanıcının yeni mi (newuser.changed == True) veya mevcut ( newuser.changed==False) olup olmadığını belirleyerek parolayı yalnızca bir kez oluşturmasına yardımcı olur.

Ansible başucu kitabı şunları içerir:

tasks:
  - name: create deployment user
    user: 
      name: deployer 
      createhome: yes 
      state: present 
    register: newuser

  - name: generate random password for user only on creation
    shell: /usr/bin/openssl rand -base64 32 | passwd --stdin deployer
    when: newuser.changed

böyle dene

vars_prompt:
 - name: "user_password"    
   prompt: "Enter a password for the user"    
   private: yes    
   encrypt: "md5_crypt" #need to have python-passlib installed in local machine before we can use it    
   confirm: yes    
   salt_size: 7

 - name: "add new user" user: name="{{user_name}}" comment="{{description_user}}" password="{{user_password}}" home="{{home_dir}}" shell="/bin/bash"

Bu yanıttaki rolün amacı, new_user_name için rastgele parola oluşturmak ve parolayı hemen sona erdirmektir. New_user_name, ilk oturum açışında parolayı değiştirmek için gereklidir.

create_user.yml:

---
# create_user playbook

- hosts: your_host_group
  become: True
  user: ansible

  roles:
    - create_user

roller / create_user / tasks / main.yml:

---
# Generate random password for new_user_name and the new_user_name
# is required to change his/her password on first logon. 

- name: Generate password for new user
  shell: makepasswd --chars=20
  register: user_password

- name: Generate encrypted password
  shell: mkpasswd --method=SHA-512 {{ user_password.stdout }}
  register: encrypted_user_password

- name: Create user account
  user: name={{ new_user_name }}
        password={{ encrypted_user_password.stdout }}
        state=present
        append=yes
        shell="/bin/bash"
        update_password=always
  when: new_user_name is defined and new_user_name in uids
  register: user_created

- name: Force user to change password
  shell: chage -d 0 {{ new_user_name }}
  when: user_created.changed

- name: User created
  debug: msg="Password for {{ new_user_name }} is {{ user_password.stdout }}"
  when: user_created.changed

Yeni bir kullanıcı oluşturmak istediğinizde:

ansible-playbook -i hosts.ini create_user.yml --extra-vars "new_user_name=kelvin"

Bu kolay yol:

---
- name: Create user
  user: name=user shell=/bin/bash home=/srv/user groups=admin,sudo generate_ssh_key=yes ssh_key_bits=2048
- name: Set password to user
  shell: echo user:plain_text_password | sudo chpasswd
  no_log: True

Benim için böyle çalıştı

- hosts: main
  vars:
  # created with:
  #  python -c "from passlib.hash import sha512_crypt; print sha512_crypt.encrypt('<password>')"
  # above command requires the PassLib library: sudo pip install passlib
  - password: '$6$rounds=100000$H/83rErWaObIruDw$DEX.DgAuZuuF.wOyCjGHnVqIetVt3qRDnTUvLJHBFKdYr29uVYbfXJeHg.IacaEQ08WaHo9xCsJQgfgZjqGZI0'

tasks:

- user: name=spree password={{password}} groups=sudo,www-data shell=/bin/bash append=yes
  sudo: yes

Tamlık için, ansible kullanarak ad-hoc komutunu göndereceğim, çünkü orada da bir yakalama var.

Öncelikle, çoğu Linux sisteminde bulunan mkpasswd yardımcı programını kullanarak şifreli bir parola oluşturmayı deneyin:

mkpasswd --method=SHA-512

Ardından yanıtlanabilir ad-hock komutunu deneyin:

ansible all -m user -a 'name=testuser shell=/bin/bash \
     comment="Test User" password=$6$XXXX' -k -u admin --sudo

Ancak şunlardan emin olun:

1. Komut tek tırnak içindedir ve iki katı DEĞİL, aksi takdirde şifreniz asla çalışmaz
2. İle çalıştırırsın --sudoveya ( useradd: cannot lock /etc/passwd; try again later) gibi bir hatayla sonuçlanırsın

Kullanıcı modülünün görev tanımı , en son Ansible sürümünde farklı olmalıdır.

tasks:
  - user: name=test password={{ password }} state=present

Yukarıdan birkaç çözümü birleştirerek, şifrelenmiş, yerel yanıtlanabilir kasa dosyasında depolanan düz metin parolalara dayalı olarak doğru parola karmalarını otomatik olarak oluşturan bir başucu kitabı oluşturdum:

---
- hosts: [your hosts]
  tasks:
  - include_vars: [path to your encrypted vault file]
  - local_action: "command openssl passwd -salt '{{password_salt}}' -1 '{{password}}'"
    register: password_hash
  - user: >
        name=[your username]
        state=present
        password="{{password_hash.stdout}}"

Kasa dosyanızın şifresini çözmek için "--ask-vault-pass" seçeneğini kullanarak bu komutu çalıştırın (şifreli bir kasayı nasıl yöneteceğinizle ilgili bilgi için ansible-vault'a bakın).

passwordAnsible usergörevine var'a geçmek için şifreli parola nasıl oluşturulur (@Brendan Wood'un yorumundan):

openssl passwd -salt 'some_plain_salt' -1 'some_plain_pass'

Sonuç şöyle görünecek:

$1$some_pla$lmVKJwdV3Baf.o.F0OOy71

userGörev örneği :

- name: Create user
  user: name="my_user" password="$1$some_pla$lmVKJwdV3Baf.o.F0OOy71"

UPD: SHA-512 kullanarak crypt buraya ve buraya bakın :

Python

$ python -c "import crypt, getpass, pwd; print crypt.crypt('password', '\$6\$saltsalt\$')"

$6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/

Perl

$ perl -e 'print crypt("password","\$6\$saltsalt\$") . "\n"'

$6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/

Yakut

$ ruby -e 'puts "password".crypt("$6$saltsalt$")'

$6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/

Oyun kitaplarında gizli anahtarları kullanmak için yanıtlayıcı kasayı kullanabilirsiniz. Parolanızı yml olarak tanımlayın.

ör. pass: secret veya

user:
  pass: secret
  name: fake

gizli dosyalarınızı şununla şifreleyin:

ansible-vault encrypt /path/to/credential.yml

ansible, şifrelemek için bir şifre soracaktır. (bu geçişin nasıl kullanılacağını açıklayacağım)

Ve sonra değişkenlerinizi istediğiniz yerde kullanabilirsiniz. Kasa anahtarı olmadan kimse okuyamaz.

Kasa anahtarı kullanımı:

başucu kitabını çalıştırırken argüman ileterek.

--ask-vault-pass: secret

veya password.txt gibi bir dosyaya kaydedebilir ve bir yere gizleyebilirsiniz. (CI kullanıcıları için yararlıdır)

--vault-password-file=/path/to/file.txt

Sizin durumunuzda: vars yml'yi dahil edin ve değişkenlerinizi kullanın.

- include_vars: /path/credential.yml

  - name: Add deployment user
    action: user name={{user.name}} password={{user.pass}}

Kullanıcı için rastgele şifre oluşturma

önce kullanıcı değişkenini tanımlamanız ve ardından aşağıdakileri takip etmeniz gerekir

görevler:

- name: Generate Passwords
  become: no
  local_action: command pwgen -N 1 8
  with_items: '{{ users }}'
  register: user_passwords

- name: Update User Passwords
  user:
    name: '{{ item.item }}'
    password: "{{ item.stdout | password_hash('sha512')}}"
    update_password: on_create
  with_items: '{{ user_passwords.results }}'

- name: Save Passwords Locally
  become: no
  local_action: copy content={{ item.stdout }} dest=./{{ item.item }}.txt
  with_items: '{{ user_passwords.results }}'

Mxx'in cevabı doğrudur ancak crypt.crypt()farklı işletim sistemleri söz konusu olduğunda python yöntemi güvenli değilsiniz (sisteminizde kullanılan glibc karma algoritmasıyla ilgili).

Örneğin, hash'inizi MacOS'tan oluşturursanız ve linux üzerinde bir oyun kitabı çalıştırırsanız işe yaramaz. Böyle bir durumda passlib ( pip install passlibyerel olarak kurmak için) kullanabilirsiniz.

from passlib.hash import md5_crypt
python -c 'import crypt; print md5_crypt.encrypt("This is my Password,salt="SomeSalt")'
'$1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI.'

Çözümlerden hiçbiri, Ubuntu'yu kontrol eden Mac'imde doğrudan çalışmadı. Diğerlerinin iyiliği için, Mxx ve JoelB yanıtlarını birleştirerek, işte mevcut Python 3 çözümü:

pip3 install passlib

python3 -c 'from passlib.hash import md5_crypt; \
      print(md5_crypt.encrypt("This is my Password", salt="SomeSalt"))'

Sonuç, $1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI.Mxx'in cevabında olduğu gibi olacaktır .

Daha da iyisi, MD5 yerine SHA512 kullanın:

python3 -c 'from passlib.hash import sha512_crypt; \
      print(sha512_crypt.encrypt("This is my Password", salt="SomeSalt"))' 

Sonuç:

6 $ $ mermi = 656000 $ SomeSalt $ oYpmnpZahIsvn5FK8g4bDFEAmGpEN114Fe6Ko4HvinzFaz5Rq2UXQxoJZ9ZQyQoi9zaBo3gBH / FEAov3FHv48

Parola kimlik doğrulamasına izin veren bir linux hesabı oluşturmanıza izin veren bir yanıtlanabilir oyun kitabı oluşturdum.

Bkz. CreateLinuxAccountWithAnsible .

Hashing uygulanmış parola, mkpasswdkomut kullanılarak oluşturulur . mkpasswdFarklı işletim sistemlerine yükleme yollarını sağladım.

Komut dosyamı kullanmak için gereken adımlar şunlardır:

1. Değiştir <your_user_name>ve <your_password>içeride run.shde istediğiniz kullanıcı adı ve şifre ile.

2. Bağlantı bilgisini inventory, ansible'ın bir kullanıcı oluşturmak üzere makineye bağlanabilmesi için değiştirin.

3. ./run.shKomut dosyasını çalıştırmak için çalıştırın.

Mkpasswd, Python vb. Dahil birçok yardımcı programı denedim. Ancak diğer araçlar tarafından oluşturulan HASH değerlerini okurken Ansible ile bazı uyumluluk sorunları var gibi görünüyor. Sonunda ansible # değerinin kendisi tarafından çalıştı.

ansible all -i localhost, -m hata ayıklama -a "msg = {{'yourpasswd' | password_hash ('sha512', 'mysecretsalt')}}"

Başucu Kitabı -

- name: User creation
  user: 
    name: username  
    uid: UID
    group: grpname
    shell: /bin/bash
    comment: "test user"
    password: "$6$mysecretsalt$1SMjoVXjYf.3sJR3a1WUxlDCmdJwC613.SUD4DOf40ASDFASJHASDFCDDDWERWEYbs8G00NHmOg29E0"

Bunu Ansible ad-hoc komut olarak gerçekleştirmek istiyorsanız, aşağıdakileri yapabilirsiniz:

$ password='SomethingSecret!'
$ ansible 192.168.1.10 -i some_inventory -b -m user -a "name=joe_user \
       update_password=always password=\"{{ \"$password\" | password_hash('sha512') }}\""

Yukarıdaki komuttan çıktı:

192.168.1.10 | SUCCESS => {
    "append": false,
    "changed": true,
    "comment": "Joe User",
    "group": 999,
    "home": "/home/joe_user",
    "move_home": false,
    "name": "joe_user",
    "password": "NOT_LOGGING_PASSWORD",
    "shell": "/bin/bash",
    "state": "present",
    "uid": 999
}

Partiye geç kaldığımı biliyorum ama kullandığım başka bir çözüm var. --stdinPasswd ikilisinde bulunmayan dağıtımlar için kullanışlı olabilir .

- hosts: localhost
  become: True
  tasks:
    - name: Change user password
      shell: "yes '{{ item.pass }}' | passwd {{ item.user }}"
      loop:
       - { pass: 123123, user: foo }
       - { pass: asdf, user: bar }
      loop_control:
        label: "{{ item.user }}"

Etiket girişi yalnızca kullanıcı adını loop_controlyazdırmaktan sorumludur . Başucu kitabının tamamı veya yalnızca kullanıcı değişkenleri (kullanabilirsiniz ) birsible-kasa ile şifrelenmelidir.vars_files:

Çözümüm arama kullanıyor ve otomatik olarak şifre oluşturuyor.

---
- hosts: 'all'
  remote_user: root
  gather_facts: no
  vars:
    deploy_user: deploy
    deploy_password: "{{ lookup('password', '/tmp/password chars=ascii_letters') }}"

  tasks:
    - name: Create deploy user
      user:
        name: "{{ deploy_user }}"
        password: "{{ deploy_password | password_hash('sha512') }}"

Pekala, partiye tamamen geç kaldım :) Rastgele şifrelerle birden fazla yerel kullanıcı oluşturan yanıtlanabilir bir oyun ihtiyacım vardı. Bu benim ortaya çıkardığım şey, yukarıdan bazı örnekleri kullandım ve bazı değişikliklerle bir araya getirdim.

password.yml ile-kullanıcı-oluştur

---
# create_user playbook

- hosts: all
  become: True
  user: root
  vars:
#Create following user
   users:
    - test24
    - test25
#with group
   group: wheel
  roles:
    - create-user-with-password

/roles/create-user-with-password/tasks/main.yml

- name: Generate password for new user
  local_action: shell pwgen -s -N 1 20
  register: user_password
  with_items: "{{ users }}"
  run_once: true

- name: Generate encrypted password
  local_action: shell python -c 'import crypt; print(crypt.crypt( "{{ item.stdout }}", crypt.mksalt(crypt.METHOD_SHA512)))'
  register: encrypted_user_password
  with_items: "{{ user_password.results }}"
  run_once: true

- name: Create new user with group
  user:
    name: "{{ item }}"
    groups: "{{ group }}"
    shell: /bin/bash
    append: yes
    createhome: yes
    comment: 'Created with ansible'
  with_items:
    - "{{ users }}"
  register: user_created

- name: Update user Passwords
  user:
    name: '{{ item.0 }}'
    password: '{{ item.1.stdout }}'
  with_together:
    - "{{ users }}"
    - "{{ encrypted_user_password.results }}"
  when: user_created.changed

- name: Force user to change the password at first login
  shell: chage -d 0 "{{ item }}"
  with_items:
    - "{{ users }}"
  when: user_created.changed

- name: Save Passwords Locally
  become: no
  local_action: copy content={{ item.stdout }} dest=./{{ item.item }}.txt
  with_items: "{{ user_password.results }}"
  when: user_created.changed