Since ansible 2.5 there is an option update_only for yum (and since ansible 2.1 only_upgrade for apt) which installs latest version only if it was already installed on the system. So, instead of collecting a list of packages in another task, you can add the option.

- name: Update subset of packages.
  yum:
    name: "{{ item }}"
    state: latest
    update_only: yes
  with_items:
    - package1
    - package2

I am myself was searching the web and this article was found before I got to the official documentation. So I think it worse to be added here.

I don't think the yum module would help in this case. It currently has 3 states: absent, present, and latest. Since it sounds like you don't want to actually install or remove the package (at least at this point) then you would need to do this in two manual steps. The first task would check to see if the package exists, then the second task would invoke a command based on the output of the first command.

If you use "rpm -q" to check if a package exists then the output would look like this for a package that exists:

# rpm -q httpd
httpd-2.2.15-15.el6.centos.1.x86_64

and like this if the package doesn't exist:

# rpm -q httpdfoo
package httpdfoo is not installed

So your ansible tasks would look something like this:

- name: Check if foo.rpm is installed
  command: rpm -q foo.rpm
  register: rpm_check

- name: Execute script if foo.rpm is not installed
  command: somescript
  when: rpm_check.stdout.find('is not installed') != -1

The rpm command will also exit with a 0 if the package exists, or a 1 if the package isn't found, so another possibility is to use:

when: rpm_check.rc == 1

Just do a search first, and only install if it returns any results:

- hosts: host
  tasks:
    - name: Search for package
      yum:
        list: <package_name>
      register: package_list

    - name: Install package
      yum:
        name: <package_name>
        state: present
      become: yes
      when: 'package_list.results | length != 0'

replace <package_name> with the package you are interested in.

Here is an alternative with failed_when, but it's quite hacky as it relies on the message returned by yum to match:

- hosts: host
  tasks:
    - name: Install package
      yum:
        name: <package_name>
        state: present
      register: result
      become: yes
      failed_when: '(result.msg | regex_replace("No package matching .* found available, installed or updated","")) != ""'

Ansible is idempotent. You can run yum module as many times as you want. If there is nothing to install that task will end with changed=false status and packages will not be re-installed.

I suspect your issue is related to the difference in state: present vs state: latest.

It looks like the yum module with state: present checks the rpmdb to see if the pkg exists and does nothing further.

Since your manual install seems to indicate you have some addition dependencies or updates related to your package, try running with state: latest which internally will run a yum check-update and see if this pulls those files in.

Building up on @gary lopez answer to add security and performance.

First you will need to get an actual list of all packages you want to see installed on your final machine, including the default ones that come with the system. I assume that list will be in var yum_rpm

Once you have that, the next step is to get the list of currently installed packages on the machine. To create an actual list we can reuse:

  - name: Get installed packages
    yum:
      list: installed
    register: __yum_packages

  - name: Make installed packages a list of names
    set_fact:
      installed_packages: "{{ __yum_packages.results | map(attribute='name') | list }}"

From there, adding and removing is just a matter of making a difference on lists. The goal here is to avoid looping on the yum module package by package (because it is damn slow and listed as a bad practice on the module documentation page) and to make the install and remove operations in one go.

  - name: align packages on system to expected
    yum:
      name: "{{ item.packages }}"
      state: "{{ item.state }}"
    loop:
      - packages: "{{ yum_rpm | difference(installed_packages) }}"
        state: present
      - packages: "{{ installed_packages | difference(yum_rpm) }}"
        state: absent
    when: item.packages | length > 0

Ansible is part of the Extra Packages for Enterprise Linux (EPEL) repository so you need to install epel-release package first

$ sudo yum install epel-release

The repo should now be visible in the repo list

$ sudo yum repolist

So now you can go ahead and install ansible

$ sudo yum install ansible

Before RHEL 7.x, the installtion needed to be done manually. Open install epel-release package and download the newest version of epel-release for EL5 or follow the commands below

$ wget https://archives.fedoraproject.org/pub/archive/epel/5/x86_64/epel-release-5-4.noarch.rpm
$ sudo rpm –ivh epel-release-latest-5.noarch.rpm
$ sudo yum repolist
$ sudo yum install ansible

In the installation manual for ansible, this is referred to as configure EPEL

Hope this helps :)

Response to second update

When installing manually you may also need to expire your cache and recreate the the local repository database before you can install software from EPEL. That can be done with the following

$ yum clean expire-cache
$ yum createrepo 

Short Generic Answer:

You should be able to just use wildcards *.

So just:

- name: Install package
  yum:
    name: package-2.6*
    state: latest 

Long Case Specific Answer:

I created a test server in AWS for your specific case and found that wildcards do indeed work (EC2 instance running CentOS 7, installing `mongodb-org-server-3.4.0*).

You do need to make sure you have properly configured the mongo repository first, but you said in the comments that you are able to download the package if you provide the full version number, which is unusual. Anyway, this is the minimal playbook I made and ran:

play.yml:

- hosts: all
  remote_user: centos
  tasks:
    - name: Add MongoDB repo for CentOS
      become: true
      copy:
        src: ./files/mongodb-org-3.4.repo
        dest: /etc/yum.repos.d/mongodb-org-3.4.repo
    - name: Install mongodb
      become: true
      yum:
        name: mongodb-org-server-3.4.0*
        state: latest # Works with 'present' too, but won't update versions

This playbook copies a local file for the repo config which looks like this (path is relative to the play.yml file):

files/mongod-org-3.4.repo:

[mongodb-org-3.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc