In Ansible collections, reusable code such as classes and functions should be placed in the module_utils directory. This is where common utility functions and libraries are typically stored for use across multiple modules.

Here are 3 Steps to Solve your coding Problem written in Python:

1. Organize the Project Directory: Your directory structure should look like this:

   /
   |__ collections
       |__ ansible_collections
           |__ my # Namespace
               |__ tools # Collection
                   |__ plugins
                       |__ modules
                           |__ my_module.py # Module
                       |__ module_utils
                           |__ my_lib.py # Utility File
   |__ my_playbook.yml
   

2. Place Reusable Functions in module_utils:

   • You should place your reusable functions inside the module_utils/my_lib.py file. This ensures that they are treated as utility files and can be imported correctly.

3. Import the Functions Correctly in my_module.py:

   • In your my_module.py, you need to import the utility functions using the correct import path relative to the module_utils directory.

Example Code:

1. my_lib.py (Utility File)

# my_lib.py
def my_func():
    # A simple function that returns a message
    return "Hello from my_func!"

# You can also define reusable classes here if needed
class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hello, {self.name}!"

2. my_module.py (Ansible Module)

# my_module.py
from ansible.module_utils.my_lib import my_func, MyClass  # Correct import

def run_module():
    # Calling the function from my_lib.py
    result = my_func()
    print(result)

    # Using the class from my_lib.py
    my_class_instance = MyClass('StackOverflow')
    print(my_class_instance.greet())

if __name__ == '__main__':
    run_module()

3. my_playbook.yml (Playbook)

---
- name: Test my_module
  hosts: localhost
  tasks:
    - name: Run custom module
      my.tools.my_module:

Explanation:

1. Directory Structure:

   • plugins/modules/my_module.py: This is your Ansible module where you are using reusable functions or classes.
   • plugins/module_utils/my_lib.py: This is where you store reusable functions and classes that can be imported by your modules.

2. Correct Importing:

   • The proper way to import functions and classes is:

     from ansible.module_utils.my_lib import my_func, MyClass
     

     This imports the functions or classes from the my_lib.py file inside the module_utils directory. The ansible.module_utils is the correct namespace in this context.

3. Running the Module:

   • When you run my_playbook.yml, Ansible will invoke your module my.tools.my_module, which uses the my_func and MyClass from my_lib.py.

Sample Output:

If you run the playbook, the output would be:

Hello from my_func!
Hello, StackOverflow!

Conclusion:

• Modules in Ansible should import reusable classes/functions from the module_utils directory.
• Always use the correct namespace to import from module_utils.
• This approach ensures clean, maintainable, and reusable code within your Ansible collection.

This should solve your problem by organizing your reusable code properly in the module_utils directory and importing it correctly in your modules.

I think you got the answer now, Thank you jeremywat.