Creando un nuevo usuario y contraseña con Ansible

Tengo una tarea ansible que crea un nuevo usuario en ubuntu 12.04;

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

se completa como se esperaba, pero cuando inicio sesión como ese usuario e intento sudo con la contraseña que configuré, siempre dice que es incorrecta. ¿Qué estoy haciendo mal?

Si lee el manual de Ansible para el usermódulo , lo dirigirá al repositorio de github de Ansible-examples para obtener detalles sobre cómo usar el passwordparámetro .

Allí verá que su contraseña debe tener hash.

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

Si su libro de jugadas o línea de comando ansible tiene su contraseña tal como está en texto sin formato, esto significa que el hash de su contraseña está registrado en su sombra archivo de es incorrecto. Eso significa que cuando intentas autenticarte con tu contraseña, su hash nunca coincidirá.

Además, consulte las preguntas frecuentes de Ansible sobre algunos matices del parámetro de contraseña y cómo usarlo correctamente.

Puede que sea demasiado tarde para responder esto, pero recientemente descubrí que los filtros jinja2 tienen la capacidad de manejar la generación de contraseñas cifradas. En mi main.ymlestoy generando la contraseña cifrada como:

- 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" y "upassword" se pasan como --extra-varsen el libro de jugadas y observe que he usado el filtro jinja2 aquí para encriptar la contraseña pasada.

He agregado el siguiente tutorial relacionado con esto en mi blog.

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

Quiero proponer otra solución más:

- 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

¿Por qué es mejor? Como ya se ha señalado aquí, las obras de Ansible deben ser idempotentes. Debe pensar en ellos no como una secuencia de acciones en estilo imperativo, sino como un estado deseado, estilo declarativo. Como resultado, debería poder ejecutarlo varias veces y obtener el mismo resultado, el mismo estado del servidor.

Todo esto suena muy bien, pero hay algunos matices. Uno de ellos es la gestión de usuarios. "Estado deseado" significa que cada vez que ejecutas una jugada que crea un usuario, se actualizará para que coincida exactamente con ese estado. Por "actualizado" me refiero a que su contraseña también se cambiará. Pero lo más probable es que no sea lo que necesitas. Por lo general, necesita crear un usuario, establecer y caducar su contraseña solo una vez, más ejecuciones de juego no deberían actualizar su contraseña.

Afortunadamente, Ansible tiene un update_passwordatributo en el usermódulo que resuelve este problema. Mezclando esto con variables registradas , también puede caducar su contraseña solo cuando el usuario esté realmente actualizado.

Tenga en cuenta que si cambia el shell del usuario manualmente (suponga que no le gusta el shell que el administrador malvado forzó en su juego), el usuario se actualizará, por lo que su contraseña expirará.

También tenga en cuenta cómo puede usar fácilmente las contraseñas iniciales de texto sin formato en las obras de teatro. No es necesario codificarlos en otro lugar y pegar hashes, puede usar el filtro Jinja2 para eso. Sin embargo, esto puede ser una falla de seguridad si alguien inicia sesión antes que usted inicialmente.

El módulo 'usuario' de Ansible gestiona usuarios, de forma idempotente . En el libro de jugadas a continuación, la primera tarea declara estado = presente para el usuario. Tenga en cuenta que ' register: newuser ' en la primera acción ayuda a la segunda acción a determinar si el usuario es nuevo (newuser.changed == True) o existente ( newuser.changed==False), para generar la contraseña solo una vez.

El libro de jugadas de Ansible tiene:

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

prueba así

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"

El propósito del rol en esta respuesta es generar una contraseña aleatoria para new_user_name y caducar la contraseña inmediatamente. Se requiere new_user_name para cambiar la contraseña en su primer inicio de sesión.

create_user.yml:

---
# create_user playbook

- hosts: your_host_group
  become: True
  user: ansible

  roles:
    - create_user

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

Cuando desee crear un nuevo usuario:

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

Esta es la forma fácil:

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

Así es como me funcionó

- 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

Solo para completar, publicaré el comando ad-hoc usando ansible, ya que también hay un problema.

Primero intente generar una contraseña encriptada usando la utilidad mkpasswd que está disponible en la mayoría de los sistemas Linux:

mkpasswd --method=SHA-512

Luego prueba el comando ansible ad-hock:

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

Pero asegúrate:

1. El comando está entre comillas simples y NO el doble, de lo contrario su contraseña nunca funcionará
2. Lo ejecutas con --sudoo terminas con un error como ( useradd: cannot lock /etc/passwd; try again later)

La definición de tareas para el módulo de usuario debe ser diferente en la última versión de Ansible.

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

Combinando algunas soluciones anteriores, creé un libro de jugadas que genera automáticamente hashes de contraseña correctos basados ​​en contraseñas de texto sin formato almacenadas en un archivo de bóveda ansible local cifrado:

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

Ejecute este comando usando la opción "--ask-vault-pass" para descifrar su archivo de bóveda (consulte ansible-vault para obtener información sobre cómo administrar una bóveda cifrada).

Cómo crear una contraseña encriptada para pasar a passwordvar a la usertarea de Ansible (del comentario de @Brendan Wood):

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

El resultado se verá así:

$1$some_pla$lmVKJwdV3Baf.o.F0OOy71

Ejemplo de usertarea:

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

UPD: cripta con SHA-512, consulte aquí y aquí :

Pitón

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

Rubí

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

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

Puede usar ansible-vault para usar claves secretas en los libros de jugadas. Defina su contraseña en yml.

ex. pasar: secreto o

user:
  pass: secret
  name: fake

cifre su archivo de secretos con:

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

ansible le pedirá una contraseña para cifrarlo. (explicaré cómo usar ese pase)

Y luego puedes usar tus variables donde quieras. Nadie puede leerlos sin clave de bóveda.

Uso de la clave de la bóveda:

a través de un argumento de paso al ejecutar el libro de jugadas.

--ask-vault-pass: secret

o puede guardar en un archivo como password.txt y esconderse en algún lugar. (útil para usuarios de CI)

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

En su caso: incluya vars yml y use sus variables.

- include_vars: /path/credential.yml

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

Generando contraseña aleatoria para el usuario

primero es necesario definir la variable de usuarios y luego seguir a continuación

Tareas:

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

La respuesta de Mxx es correcta pero tú, la pitón. crypt.crypt() método no es seguro cuando están involucrados diferentes sistemas operativos (relacionado con el algoritmo hash glibc utilizado en su sistema).

Por ejemplo, no funcionará si genera su hash desde MacOS y ejecuta un libro de jugadas en Linux. En tal caso, puede usar passlib ( pip install passlibpara instalar localmente).

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

Ninguna de las soluciones funcionó directamente en mi Mac que controlaba Ubuntu. Entonces, por el bien de los demás, combinando las respuestas de Mxx y JoelB, aquí está la solución actual de Python 3:

pip3 install passlib

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

El resultado será $1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI., como en la respuesta de Mxx.

Mejor aún , use SHA512 en lugar de MD5:

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

Resultado:

$ 6 $ rondas = 656000 $ SomeSal $ oYpmnpZahIsvn5FK8g4bDFEAmGpEN114Fe6Ko4HvinzFaz5Rq2UXQxoJZ9ZQyQoi9zaBo3gBH / FEAov3FHv48

He creado un libro de jugadas ansible que le permite crear una cuenta de Linux que permite la autenticación de contraseña.

Consulte CreateLinuxAccountWithAnsible .

La contraseña hash se genera usando el mkpasswdcomando. He proporcionado las formas de instalar mkpasswden diferentes sistemas operativos.

Estos son los pasos necesarios para usar mi script:

1. Reemplace <your_user_name>y <your_password>adentro run.shcon su nombre de usuario y contraseña deseados.

2. Cambie la información de conexión inventorypara que ansible pueda conectarse a la máquina para crear un usuario.

3. Ejecutar ./run.shpara ejecutar el script.

Si desea lograr esto como un comando ad-hoc de Ansible, puede hacer lo siguiente:

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

Salida del comando anterior:

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
}

Sé que llego tarde a la fiesta, pero hay otra solución que estoy usando. Puede ser útil para las distribuciones que no tienen el --stdinbinario passwd.

- 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_controles responsable de imprimir solo el nombre de usuario. Todo el libro de jugadas o solo las variables de usuario (que puede usar vars_files:) deben estar encriptadas con ansible-vault.

Mi solución es usar la búsqueda y generar una contraseña automáticamente.

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

Probé muchas utilidades, incluidas mkpasswd, Python, etc. Pero parece que hay algún problema de compatibilidad con Ansible al leer los valores HASH generados por otras herramientas. Así que finalmente funcionó con ansible # value.

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

Libro de jugadas -

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

Bueno, llegué tarde a la fiesta :) Tenía la necesidad de un juego ansible que creara múltiples usuarios locales con contraseñas aleatorias. Esto es lo que se me ocurrió, utilicé algunos de los ejemplos de arriba y los combiné con algunos cambios.

crear-usuario-con-contraseña.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