Erstellen eines neuen Benutzers und Passworts mit Ansible

Ich habe eine ansible Aufgabe, die einen neuen Benutzer auf Ubuntu 12.04 erstellt;

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

Es wird wie erwartet abgeschlossen, aber wenn ich mich als dieser Benutzer anmelde und versuche, mit dem von mir festgelegten Passwort zu sudo, heißt es immer, dass es falsch ist. Was mache ich falsch?

Wenn Sie das Handbuch für Ansible für userModule lesen , werden Sie zum Ansible-Beispiel- Github-Repo weitergeleitet, um Einzelheiten zur Verwendung von passwordParametern zu erfahren .

Dort sehen Sie, dass Ihr Passwort gehasht werden muss.

- 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}}

Wenn Ihr Playbook oder Ihre ansible Befehlszeile Ihr Passwort so wie es ist im Klartext hat, bedeutet dies, dass Ihr in Ihrer Schattendatei aufgezeichneter Passwort-Hash falsch ist. Das heißt, wenn Sie versuchen, sich mit Ihrem Passwort zu authentifizieren, stimmt der Hash nie überein.

Siehe auch Ansible FAQ in Bezug auf einige Nuancen von Passwort - Parameter und wie richtig es zu benutzen.

Ich bin vielleicht zu spät, um darauf zu antworten, aber kürzlich habe ich herausgefunden, dass jinja2-Filter die Generierung verschlüsselter Passwörter ermöglichen. In meinem main.ymlgeneriere ich das verschlüsselte Passwort als:

- 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" und "upassword" werden als übergeben --extra-vars das Playbook übergeben und ich habe festgestellt, dass ich hier den jinja2-Filter verwendet habe, um das übergebene Passwort zu verschlüsseln.

Ich habe das dazugehörige Tutorial zu meinem Blog hinzugefügt

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

Ich möchte noch eine andere Lösung vorschlagen:

- 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

Warum ist es besser? Wie hier bereits erwähnt, sollten Ansible-Spiele idempotent sein. Sie sollten sie nicht als eine Abfolge von Aktionen im imperativen Stil betrachten, sondern als einen gewünschten Zustand, einen deklarativen Stil. Infolgedessen sollten Sie es mehrmals ausführen können und dasselbe Ergebnis und denselben Serverstatus erhalten.

Das klingt alles großartig, aber es gibt einige Nuancen. Einer von ihnen verwaltet Benutzer. "Gewünschter Status" bedeutet, dass jedes Mal, wenn Sie ein Spiel ausführen, das einen Benutzer erstellt, dieser aktualisiert wird, um genau diesem Status zu entsprechen. Mit "aktualisiert" meine ich, dass auch sein Passwort geändert wird. Aber höchstwahrscheinlich ist es nicht das, was Sie brauchen. Normalerweise müssen Sie einen Benutzer erstellen, sein Passwort nur einmal festlegen und ablaufen lassen. Weitere Wiedergabeläufe sollten sein Passwort nicht aktualisieren.

Glücklicherweise hat Ansible ein update_passwordAttribut im userModul , das dieses Problem löst. Wenn Sie dies mit registrierten Variablen mischen, können Sie sein Passwort auch nur dann ablaufen lassen, wenn der Benutzer tatsächlich aktualisiert wird.

Beachten Sie, dass der Benutzer aktualisiert wird, wenn Sie die Shell des Benutzers manuell ändern (angenommen, Sie mögen die Shell nicht, die der böse Administrator in seinem Spiel erzwungen hat), sodass sein Passwort abgelaufen ist.

Beachten Sie auch, wie Sie einfache Klartext-Anfangspasswörter in Spielen verwenden können. Sie müssen sie nicht woanders codieren und Hashes einfügen. Sie können dafür den Jinja2-Filter verwenden . Dies kann jedoch eine Sicherheitslücke sein, wenn sich jemand vor Ihrer ersten Anmeldung anmeldet.

Das Ansible-Modul "Benutzer" verwaltet Benutzer auf idempotente Weise. Im folgenden Playbook deklariert die erste Aufgabe state = present für den Benutzer. Beachten Sie, dass ' register: newuser ' in der ersten Aktion der zweiten Aktion hilft, festzustellen, ob der Benutzer neu (newuser.changed == True) oder vorhanden (newuser.changed==False ) ist, und das Kennwort nur einmal zu generieren.

Das Ansible-Spielbuch enthält:

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

versuche es so

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"

Der Zweck der Rolle in dieser Antwort besteht darin, ein zufälliges Kennwort für new_user_name zu generieren und das Kennwort sofort abzulaufen. Der neue_Benutzername ist erforderlich, um das Kennwort bei seiner ersten Anmeldung zu ändern.

create_user.yml:

---
# create_user playbook

- hosts: your_host_group
  become: True
  user: ansible

  roles:
    - create_user

Rollen / create_user / task / 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

Wenn Sie einen neuen Benutzer erstellen möchten:

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

Dies ist der einfache Weg:

---
- 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

So hat es bei mir funktioniert

- 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

Der Vollständigkeit halber werde ich den Ad-hoc-Befehl mit ansible veröffentlichen, da es dort auch einen Haken gibt.

Versuchen Sie zunächst, ein verschlüsseltes Kennwort mit dem Dienstprogramm mkpasswd zu generieren, das auf den meisten Linux-Systemen verfügbar ist:

mkpasswd --method=SHA-512

Versuchen Sie dann den ansible ad-hock-Befehl:

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

Aber stellen Sie sicher:

1. Der Befehl steht in einfachen Anführungszeichen und NICHT doppelt, sonst funktioniert Ihr Passwort nie
2. Sie führen es mit aus --sudooder Sie erhalten einen Fehler wie ( useradd: cannot lock /etc/passwd; try again later)

Die Aufgabendefinition für das Benutzermodul sollte in der neuesten Ansible-Version unterschiedlich sein.

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

Aus einigen Lösungen von oben habe ich ein Playbook erstellt, das automatisch korrekte Passwort-Hashes basierend auf Klartext-Passwörtern generiert, die in einer verschlüsselten, lokalen ansible-Tresordatei gespeichert sind:

---
- 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}}"

Führen Sie diesen Befehl mit der Option "--ask-vault-pass" aus, um Ihre Tresordatei zu entschlüsseln (Informationen zum Verwalten eines verschlüsselten Tresors finden Sie unter ansible-vault).

So erstellen Sie ein verschlüsseltes Kennwort für die Übergabe an passwordvar an die Ansible- userAufgabe (aus dem Kommentar von @Brendan Wood):

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

Das Ergebnis sieht folgendermaßen aus:

$1$some_pla$lmVKJwdV3Baf.o.F0OOy71

Beispiel einer userAufgabe:

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

UPD: Krypta mit SHA-512 siehe hier und hier :

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/

Rubin

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

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

Sie können ansible-vault verwenden, um geheime Schlüssel in Spielbüchern zu verwenden. Definieren Sie Ihr Passwort in yml.

Ex. Pass: geheim oder

user:
  pass: secret
  name: fake

verschlüsseln Sie Ihre Geheimdatei mit:

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

ansible fragt nach einem Passwort, um es zu verschlüsseln. (Ich werde erklären, wie man diesen Pass benutzt)

Und dann können Sie Ihre Variablen verwenden, wo Sie möchten. Niemand kann sie ohne Tresorschlüssel lesen.

Verwendung des Tresorschlüssels:

über übergebene Argumente beim Ausführen von Playbook.

--ask-vault-pass: secret

oder Sie können in einer Datei wie password.txt speichern und irgendwo verstecken. (nützlich für CI-Benutzer)

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

In Ihrem Fall: Fügen Sie vars yml hinzu und verwenden Sie Ihre Variablen.

- include_vars: /path/credential.yml

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

Zufälliges Passwort für Benutzer generieren

Zuerst muss die Benutzervariable definiert werden, dann folgen Sie unten

Aufgaben:

- 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 }}'

Die Antwort von Mxx ist richtig, aber Sie, die Python- crypt.crypt()Methode, ist nicht sicher, wenn verschiedene Betriebssysteme beteiligt sind (im Zusammenhang mit dem auf Ihrem System verwendeten Glibc-Hash-Algorithmus).

Zum Beispiel funktioniert es nicht, wenn Sie Ihren Hash unter MacOS generieren und ein Playbook unter Linux ausführen. In diesem Fall können Sie passlib verwenden ( pip install passlibum lokal zu installieren).

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

Keine der Lösungen funktionierte direkt auf meinem Mac, der Ubuntu steuert. Für andere, die Mxx- und JoelB-Antworten kombinieren, ist hier die aktuelle Python 3-Lösung:

pip3 install passlib

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

Das Ergebnis wird $1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI.wie in der Antwort von Mxx sein.

Besser noch , verwenden Sie SHA512 anstelle von MD5:

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

Ergebnis:

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

Ich habe ein Ansible-Playbook erstellt, mit dem Sie ein Linux-Konto erstellen können, das die Kennwortauthentifizierung ermöglicht.

Siehe CreateLinuxAccountWithAnsible .

Das Hash-Passwort wird mit dem mkpasswdBefehl generiert . Ich habe die Möglichkeiten zur Installation bereitgestelltmkpasswd auf verschiedenen Betriebssystemen .

Hier sind die Schritte, die zur Verwendung meines Skripts erforderlich sind:

1. Ersetzen <your_user_name>und <your_password>innen run.shdurch Ihren gewünschten Benutzernamen und Passwort.

2. Ändern Sie die Verbindungsinformationen inventoryso, dass ansible eine Verbindung zum Computer herstellen kann, um einen Benutzer zu erstellen.

3. Ausführen ./run.sh, um das Skript auszuführen.

Wenn Sie dies als Ansible-Ad-hoc-Befehl ausführen möchten, können Sie Folgendes tun:

$ 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') }}\""

Ausgabe vom obigen Befehl:

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
}

Ich weiß, dass ich zu spät zur Party komme, aber es gibt eine andere Lösung, die ich benutze. Dies kann für Distributionen nützlich sein, die keine --stdinpasswd-Binärdatei haben.

- 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 }}"

Label in loop_controlist dafür verantwortlich, nur den Benutzernamen zu drucken . Das gesamte Playbook oder nur Benutzervariablen (die Sie verwenden können vars_files:) sollten mit ansible-vault verschlüsselt werden.

Meine Lösung verwendet die Suche und generiert automatisch ein Passwort.

---
- 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') }}"

Versuchte viele Dienstprogramme, einschließlich mkpasswd, Python usw. Aber es scheint, dass es ein Kompatibilitätsproblem mit Ansible beim Lesen von HASH-Werten gibt, die von anderen Tools generiert wurden. Also funktionierte es schließlich mit ansible # value selbst.

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

Spielbuch -

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

Nun, ich bin total spät zum Feiern :) Ich hatte das Bedürfnis nach einem vernünftigen Spiel, das mehrere lokale Benutzer mit zufälligen Passwörtern erstellt. Das, was ich mir ausgedacht habe, hat einige Beispiele von oben verwendet und sie mit einigen Änderungen zusammengestellt.

create-user-with-password.yml

---
# 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