ansible

const AclName = "acl"

Set and retrieve file ACL information.

const AlternativesName = "alternatives"

Manages symbolic links using the `update-alternatives` tool. Useful when multiple programs are installed but provide similar functionality (for example, different editors).

const AndroidSdkName = "android_sdk"

Manages Android SDK packages. Allows installation from different channels (stable, beta, dev, canary). Allows installation of packages to a non-default SDK root directory.

const AnsibleGalaxyInstallName = "ansible_galaxy_install"

This module allows the installation of Ansible collections or roles using `ansible-galaxy`.

const ApkName = "apk"

Manages `apk` packages for Alpine Linux.

const AptKeyName = "apt_key"

Add or remove an `apt` key, optionally downloading it.

const AptName = "apt"

Manages `apt` packages (such as for Debian/Ubuntu).

const AptRepoName = "apt_repo"

Manages APT repositories using `apt-repo` tool. See `https://www.altlinux.org/Apt-repo` for details about `apt-repo`.

const AptRepositoryName = "apt_repository"

Add or remove an APT repositories in Ubuntu and Debian.

const AptRpmName = "apt_rpm"

Manages packages with `apt-rpm`. Both low-level (`rpm`) and high-level (`apt- get`) package manager binaries required.

const AssembleName = "assemble"

Assembles a configuration file from fragments. Often a particular program will take a single configuration file and does not support a `conf.d` style structure where it is easy to build up the configuration from multiple sources. `ansible.builtin.assemble` will take a directory of files that can be local or have already been transferred to the system, and concatenate them together to produce a destination file. Files are assembled in string sorting order. Puppet calls this idea `fragments`.

const AtName = "at"

Use this module to schedule a command or script file to run once in the future. All jobs are executed in the 'a' queue.

const AuthorizedKeyName = "authorized_key"

Adds or removes SSH authorized keys for particular user accounts.

const AwallName = "awall"

This modules allows for enable/disable/activate of `awall` policies. Alpine Wall (`awall`) generates a firewall configuration from the enabled policy files and activates the configuration on the system.

const BeadmName = "beadm"

Create, delete or activate ZFS boot environments. Mount and unmount ZFS boot environments.

const BlockinfileName = "blockinfile"

This module will insert/update/remove a block of multi-line text surrounded by customizable marker lines.

const BootcManageName = "bootc_manage"

This module manages the switching and upgrading of `bootc`.

const BowerName = "bower"

Manage bower packages with `bower`.

const BzrName = "bzr"

Manage `bzr` branches to deploy files or software.

const CapabilitiesName = "capabilities"

This module manipulates files privileges using the Linux capabilities(7) system.

const CargoName = "cargo"

Manage Rust packages with cargo.

const CommandName = "command"

The `ansible.builtin.command` module takes the command name followed by a list of space-delimited arguments. The given command will be executed on all selected nodes. The command(s) will not be processed through the shell, so operations like `"*"`, `"<"`, `">"`, `"|"`, `";"` and `"&"` will not work. Also, environment variables are resolved via Python, not shell, see `expand_argument_vars` and are left unchanged if not matched. Use the `ansible.builtin.shell` module if you need these features. To create `command` tasks that are easier to read than the ones using space- delimited arguments, pass parameters using the `args` `task keyword,https://d ocs.ansible.com/ansible/latest/reference_appendices/playbooks_keywords.html#t ask` or use `cmd` parameter. Either a free form command or `cmd` parameter is required, see the examples. For Windows targets, use the `ansible.windows.win_command` module instead.

const CopyName = "copy"

The `ansible.builtin.copy` module copies a file or a directory structure from the local or remote machine to a location on the remote machine. File system meta-information (permissions, ownership, etc.) may be set, even when the file or directory already exists on the target system. Some meta-information may be copied on request. Get meta-information with the `ansible.builtin.stat` module. Set meta-information with the `ansible.builtin.file` module. Use the `ansible.builtin.fetch` module to copy files from remote locations to the local box. If you need variable interpolation in copied files, use the `ansible.builtin.template` module. Using a variable with the `content` parameter produces unpredictable results. For Windows targets, use the `ansible.windows.win_copy` module instead.

const CronName = "cron"

Use this module to manage crontab and environment variables entries. This module allows you to create environment variables and named crontab entries, update, or delete them. When crontab jobs are managed: the module includes one line with the description of the crontab entry `"#Ansible: <name>"` corresponding to the `name` passed to the module, which is used by future ansible/module calls to find/check the state. The `name` parameter should be unique, and changing the `name` value will result in a new cron task being created (or a different one being removed). When environment variables are managed, no comment line is added, but, when the module needs to find/check the state, it uses the `name` parameter to find the environment variable definition line. When using symbols such as `%`, they must be properly escaped.

const CrypttabName = "crypttab"

Control Linux encrypted block devices that are set up during system boot in `/etc/crypttab`.

const Deb822RepositoryName = "deb822_repository"

Add and remove deb822 formatted repositories in Debian based distributions.

const DebconfName = "debconf"

Configure a .deb package using debconf-set-selections. Or just query existing selections.

const DeployHelperName = "deploy_helper"

The Deploy Helper manages some of the steps common in deploying software. It creates a folder structure, manages a symlink for the current release and cleans up old releases. Running it with the `state=query` or `state=present` will return the `deploy_helper` fact. `project_path`, whatever you set in the `path` parameter, `current_path`, the path to the symlink that points to the active release, `releases_path`, the path to the folder to keep releases in, `shared_path`, the path to the folder to keep shared resources in, `unfinished_filename`, the file to check for to recognize unfinished builds, `previous_release`, the release the 'current' symlink is pointing to, `previous_release_path`, the full path to the 'current' symlink target, `new_release`, either the `release` parameter or a generated timestamp, `new_release_path`, the path to the new release folder (not created by the module).

const DjangoCheckName = "django_check"

This module is a wrapper for the execution of `django-admin check`.

const DjangoCommandName = "django_command"

This module allows the execution of arbitrary Django admin commands.

const DjangoCreatecachetableName = "django_createcachetable"

This module is a wrapper for the execution of `django-admin createcachetable`.

const DjangoManageName = "django_manage"

Manages a Django application using the `manage.py` application frontend to `django-admin`. With the `virtualenv` parameter, all management commands will be executed by the given `virtualenv` installation.

const Dnf5Name = "dnf5"

Installs, upgrade, removes, and lists packages and groups with the `dnf5` package manager. WARNING: The `dnf5` package manager is still under development and not all features that the existing `ansible.builtin.dnf` module provides are implemented in `ansible.builtin.dnf5`, please consult specific options for more information.

const DnfConfigManagerName = "dnf_config_manager"

This module enables or disables repositories using the `dnf config-manager` sub-command.

const DnfName = "dnf"

Installs, upgrade, removes, and lists packages and groups with the `dnf` package manager.

const DnfVersionlockName = "dnf_versionlock"

Locks package versions using the `versionlock` plugin in `dnf` based systems. This plugin takes a set of name and versions for packages and excludes all other versions of those packages. This allows you to for example protect packages from being updated by newer versions. The state of the plugin that reflects locking of packages is the `locklist`.

const DockerComposeV2ExecName = "docker_compose_v2_exec"

Uses Docker Compose to run a command in a service's container. This can be used to run one-off commands in an existing service's container, and encapsulates `docker compose exec`.

const DockerComposeV2Name = "docker_compose_v2"

Uses Docker Compose to start or shutdown services.

const DockerComposeV2PullName = "docker_compose_v2_pull"

Uses Docker Compose to pull images for a project.

const DockerComposeV2RunName = "docker_compose_v2_run"

Uses Docker Compose to run a command in a new container for a service. This encapsulates `docker compose run`.

const DockerConfigName = "docker_config"

Create and remove Docker configs in a Swarm environment. Similar to `docker config create` and `docker config rm`. Adds to the metadata of new configs `ansible_key`, an encrypted hash representation of the data, which is then used in future runs to test if a config has changed. If `ansible_key` is not present, then a config will not be updated unless the `force` option is set. Updates to configs are performed by removing the config and creating it again.

const DockerContainerCopyIntoName = "docker_container_copy_into"

Copy a file into a Docker container. Similar to `docker cp`. To copy files in a non-running container, you must provide the `owner_id` and `group_id` options. This is also necessary if the container does not contain a `/bin/sh` shell with an `id` tool.

const DockerContainerExecName = "docker_container_exec"

Executes a command in a Docker container.

const DockerContainerInfoName = "docker_container_info"

Retrieves facts about a docker container. Essentially returns the output of `docker inspect <name>`, similar to what `community.docker.docker_container` returns for a non-absent container.

const DockerContainerName = "docker_container"

Manage the life cycle of Docker containers. Supports check mode. Run with `--check` and `--diff` to view config difference and list of actions to be taken.

const DockerContextInfoName = "docker_context_info"

Return information on Docker contexts. This includes some generic information, as well as a R`contexts[].config` dictionary that can be used for module defaults for all community.docker modules that use the `community.docker.docker` module defaults group.

const DockerHostInfoName = "docker_host_info"

Retrieves facts about a docker host. Essentially returns the output of `docker system info`. The module also allows to list object names for containers, images, networks and volumes. It also allows to query information on disk usage. The output differs depending on API version of the docker daemon. If the docker daemon cannot be contacted or does not meet the API version requirements, the module will fail.

const DockerImageBuildName = "docker_image_build"

This module allows you to build Docker images using Docker's buildx plugin (BuildKit). Note that the module is `not idempotent` in the sense of classical Ansible modules. The only idempotence check is whether the built image already exists. This check can be disabled with the `rebuild` option.

const DockerImageExportName = "docker_image_export"

Creates an archive (tarball) from one or more Docker images. This can be copied to another machine and loaded with `community.docker.docker_image_load`.

const DockerImageInfoName = "docker_image_info"

Provide one or more image names, and the module will inspect each, returning an array of inspection results. If an image does not exist locally, it will not appear in the results. If you want to check whether an image exists locally, you can call the module with the image name, then check whether the result list is empty (image does not exist) or has one element (the image exists locally). The module will not attempt to pull images from registries. Use `community.docker.docker_image` with `community.docker.docker_image#module:source=pull` to ensure an image is pulled.

const DockerImageLoadName = "docker_image_load"

Load one or multiple Docker images from a `.tar` archive, and return information on the loaded image(s).

const DockerImageName = "docker_image"

Build, load or pull an image, making the image available for creating containers. Also supports tagging an image, pushing an image, and archiving an image to a `.tar` file. We recommend to use the individual modules `community.docker.docker_image_build`, `community.docker.docker_image_export`, `community.docker.docker_image_load`, `community.docker.docker_image_pull`, `community.docker.docker_image_push`, `community.docker.docker_image_remove`, and `community.docker.docker_image_tag` instead of this module.

const DockerImagePullName = "docker_image_pull"

Pulls a Docker image from a registry.

const DockerImagePushName = "docker_image_push"

Pushes a Docker image to a registry.

const DockerImageRemoveName = "docker_image_remove"

Remove Docker images from the Docker daemon.

const DockerImageTagName = "docker_image_tag"

This module allows to tag Docker images with new names and/or tags.

const DockerLoginName = "docker_login"

Provides functionality similar to the `docker login` command. Authenticate with a docker registry and add the credentials to your local Docker config file respectively the credentials store associated to the registry. Adding the credentials to the config files resp. the credential store allows future connections to the registry using tools such as Ansible's Docker modules, the Docker CLI and Docker SDK for Python without needing to provide credentials. Running in check mode will perform the authentication without updating the config file.

const DockerNetworkInfoName = "docker_network_info"

Retrieves facts about a docker network. Essentially returns the output of `docker network inspect <name>`, similar to what `community.docker.docker_network` returns for a non-absent network.

const DockerNetworkName = "docker_network"

Create/remove Docker networks and connect containers to them. Performs largely the same function as the `docker network` CLI subcommand.

const DockerNodeInfoName = "docker_node_info"

Retrieves facts about a docker node. Essentially returns the output of `docker node inspect <name>`. Must be executed on a host running as Swarm Manager, otherwise the module will fail.

const DockerNodeName = "docker_node"

Manages the Docker nodes through a Swarm Manager. This module allows to change the node's role, its availability, and to modify, add or remove node labels.

const DockerPluginName = "docker_plugin"

This module allows to install, delete, enable and disable Docker plugins. Performs largely the same function as the `docker plugin` CLI subcommand.

const DockerPruneName = "docker_prune"

Allows to run `docker container prune`, `docker image prune`, `docker network prune` and `docker volume prune` through the Docker API.

const DockerSecretName = "docker_secret"

Create and remove Docker secrets in a Swarm environment. Similar to `docker secret create` and `docker secret rm`. Adds to the metadata of new secrets `ansible_key`, an encrypted hash representation of the data, which is then used in future runs to test if a secret has changed. If `ansible_key` is not present, then a secret will not be updated unless the `force` option is set. Updates to secrets are performed by removing the secret and creating it again.

const DockerStackInfoName = "docker_stack_info"

Retrieve information on docker stacks using the `docker stack` command on the target node (see examples).

const DockerStackName = "docker_stack"

Manage docker stacks using the `docker stack` command on the target node (see examples).

const DockerStackTaskInfoName = "docker_stack_task_info"

Retrieve information on docker stacks tasks using the `docker stack` command on the target node (see examples).

const DockerSwarmInfoName = "docker_swarm_info"

Retrieves facts about a Docker Swarm. Returns lists of swarm objects names for the services - nodes, services, tasks. The output differs depending on API version available on docker host. Must be run on Swarm Manager node; otherwise module fails with error message. It does return boolean flags in on both error and success which indicate whether the docker daemon can be communicated with, whether it is in Swarm mode, and whether it is a Swarm Manager node.

const DockerSwarmName = "docker_swarm"

Create a new Swarm cluster. Add/Remove nodes or managers to an existing cluster.

const DockerSwarmServiceInfoName = "docker_swarm_service_info"

Retrieves information about a docker service. Essentially returns the output of `docker service inspect <name>`. Must be executed on a host running as Swarm Manager, otherwise the module will fail.

const DockerSwarmServiceName = "docker_swarm_service"

Manages docker services through a swarm manager node. This modules does not support updating services in a stack.

const DockerVolumeInfoName = "docker_volume_info"

Performs largely the same function as the `docker volume inspect` CLI subcommand.

const DockerVolumeName = "docker_volume"

Create/remove Docker volumes. Performs largely the same function as the `docker volume` CLI subcommand.

const DpkgDivertName = "dpkg_divert"

A diversion is for `dpkg` the knowledge that only a given package (or the local administrator) is allowed to install a file at a given location. Other packages shipping their own version of this file will be forced to `divert` it, that is to install it at another location. It allows one to keep changes in a file provided by a debian package by preventing it being overwritten on package upgrade. This module manages diversions of debian packages files using the `dpkg- divert` commandline tool. It can either create or remove a diversion for a given file, but also update an existing diversion to modify its `holder` and/or its `divert` location.

const DpkgSelectionsName = "dpkg_selections"

Change dpkg package selection state via `--get-selections` and `--set- selections`.

const ExpectName = "expect"

The `ansible.builtin.expect` module executes a command and responds to prompts. The given command will be executed on all selected nodes. It will not be processed through the shell, so variables like `$HOME` and operations like `"<"`, `">"`, `"|"`, and `"&"` will not work.

const FacterFactsName = "facter_facts"

Runs the `facter` discovery program (`https://github.com/puppetlabs/facter`) on the remote system, returning Ansible facts from the JSON data that can be useful for inventory purposes.

const FacterName = "facter"

Runs the `facter` discovery program (`https://github.com/puppetlabs/facter`) on the remote system, returning JSON data that can be useful for inventory purposes.

const FileName = "file"

Set attributes of files, directories, or symlinks and their targets. Alternatively, remove files, symlinks or directories. Many other modules support the same options as the `ansible.builtin.file` module - including `ansible.builtin.copy`, `ansible.builtin.template`, and `ansible.builtin.assemble`. For Windows targets, use the `ansible.windows.win_file` module instead.

const FilesizeName = "filesize"

This module is a simple wrapper around `dd` to create, extend or truncate a file, given its size. It can be used to manage swap files (that require contiguous blocks) or alternatively, huge sparse files.

const FilesystemName = "filesystem"

This module creates a filesystem.

const FindName = "find"

Return a list of files based on specific criteria. Multiple criteria are AND'd together. For Windows targets, use the `ansible.windows.win_find` module instead. This module does not use the `find` command, it is a much simpler and slower Python implementation. It is intended for small and simple uses. Those that need the extra power or speed and have expertise with the UNIX command, should use it directly.

const FirewalldInfoName = "firewalld_info"

This module gathers information about firewalld rules.

const FirewalldName = "firewalld"

This module allows for addition or deletion of services and ports (either TCP or UDP) in either running or permanent firewalld rules.

const FlatpakName = "flatpak"

Allows users to add or remove flatpaks. See the `community.general.flatpak_remote` module for managing flatpak remotes.

const Gconftool2InfoName = "gconftool2_info"

This module allows retrieving application preferences from the GConf database, with the help of `gconftool-2`.

const Gconftool2Name = "gconftool2"

This module allows for the manipulation of GNOME 2 Configuration using `gconftool-2`. Please see the gconftool-2(1) man pages for more details.

const GemName = "gem"

Manage installation and uninstallation of Ruby gems.

const GetUrlName = "get_url"

Downloads files from HTTP, HTTPS, or FTP to the remote server. The remote server `must` have direct access to the remote resource. By default, if an environment variable `<protocol>_proxy` is set on the target host, requests will be sent through that proxy. This behaviour can be overridden by setting a variable for this task (see `setting the environment,playbooks_environment`), or by using the use_proxy option. HTTP redirects can redirect from HTTP to HTTPS so you should be sure that your proxy environment for both protocols is correct. From Ansible 2.4 when run with `--check`, it will do a HEAD request to validate the URL but will not download the entire file or verify it against hashes and will report incorrect changed status. For Windows targets, use the `ansible.windows.win_get_url` module instead.

const GetentName = "getent"

Runs getent against one of its various databases and returns information into the host's facts, in a `getent_<database>` prefixed variable.

const GitConfigInfoName = "git_config_info"

The `community.general.git_config_info` module reads the git configuration by invoking `git config`.

const GitConfigName = "git_config"

The `community.general.git_config` module changes git configuration by invoking `git config`. This is needed if you do not want to use `ansible.builtin.template` for the entire git config file (for example because you need to change just `user.email` in `/etc/.git/config`). Solutions involving `ansible.builtin.command` are cumbersome or do not work correctly in check mode.

const GitName = "git"

Manage `git` checkouts of repositories to deploy files or software.

const GroupName = "group"

Manage presence of groups on a host. For Windows targets, use the `ansible.windows.win_group` module instead.

const GunicornName = "gunicorn"

Starts gunicorn with the parameters specified. Common settings for gunicorn configuration are supported. For additional configuration use a config file See `https://gunicorn-docs.readthedocs.io/en/latest/settings.html` for more options. It's recommended to always use the chdir option to avoid problems with the location of the app.

const HomebrewCaskName = "homebrew_cask"

Manages Homebrew casks.

const HomebrewName = "homebrew"

Manages Homebrew packages.

const HomebrewServicesName = "homebrew_services"

Manages daemons and services using Homebrew.

const HomebrewTapName = "homebrew_tap"

Tap external Homebrew repositories.

const HomectlName = "homectl"

Manages a user's home directory managed by systemd-homed.

const HostnameName = "hostname"

Set system's hostname. Supports most OSs/Distributions including those using `systemd`. Windows, HP-UX, and AIX are not currently supported.

const HponcfgName = "hponcfg"

This modules configures the HP iLO interface using `hponcfg`.

const IniFileName = "ini_file"

Manage (add, remove, change) individual settings in an INI-style file without having to manage the file as a whole with, say, `ansible.builtin.template` or `ansible.builtin.assemble`. Adds missing sections if they do not exist. This module adds missing ending newlines to files to keep in line with the POSIX standard, even when no other modifications need to be applied.

const InstallpName = "installp"

Manage packages using 'installp' on AIX.

const InterfacesFileName = "interfaces_file"

Manage (add, remove, change) individual interface options in an interfaces- style file without having to manage the file as a whole with, say, `ansible.builtin.template` or `ansible.builtin.assemble`. Interface has to be presented in a file. Read information about interfaces from interfaces-styled files.

const IpNetnsName = "ip_netns"

Create or delete network namespaces using the `ip` command.

const IpmiBootName = "ipmi_boot"

Use this module to manage order of boot devices.

const IpmiPowerName = "ipmi_power"

Use this module for power management.

const IptablesName = "iptables"

`ansible.builtin.iptables` is used to set up, maintain, and inspect the tables of IP packet filter rules in the Linux kernel. This module does not handle the saving and/or loading of rules, but rather only manipulates the current rules that are present in memory. This is the same as the behaviour of the `iptables` and `ip6tables` command which this module uses internally.

const IsoCreateName = "iso_create"

This module is used to generate ISO file with specified path of files.

const IsoCustomizeName = "iso_customize"

This module is used to add/remove/change files in ISO file. The file inside ISO will be overwritten if it exists by option `add_files`.

const IsoExtractName = "iso_extract"

This module has two possible ways of operation. If 7zip is installed on the system, this module extracts files from an ISO into a temporary directory and copies files to a given destination, if needed. If the user has mount-capabilities (CAP_SYS_ADMIN on Linux) this module mounts the ISO image to a temporary location, and copies files to a given destination, if needed.

const JbossName = "jboss"

Deploy applications to JBoss standalone using the filesystem.

const KdeconfigName = "kdeconfig"

Add or change individual settings in KDE configuration files. It uses `kwriteconfig` under the hood.

const KernelBlacklistName = "kernel_blacklist"

Add or remove kernel modules from blacklist.

const KeyringInfoName = "keyring_info"

This module uses the `keyring Python library, https://pypi.org/project/keyring/` to retrieve passphrases for a given service and username from the OS' native keyring.

const KibanaPluginName = "kibana_plugin"

This module can be used to manage Kibana plugins.

const KnownHostsName = "known_hosts"

The `ansible.builtin.known_hosts` module lets you add or remove host keys from the `known_hosts` file. Starting at Ansible 2.2, multiple entries per host are allowed, but only one for each key type supported by ssh. This is useful if you're going to want to use the `ansible.builtin.git` module over ssh, for example. If you have a very large number of host keys to manage, you will find the `ansible.builtin.template` module more useful.

const LbuName = "lbu"

Manage Local Backup Utility of Alpine Linux in run-from-RAM mode.

const LineinfileName = "lineinfile"

This module ensures a particular line is in a file, or replace an existing line using a back-referenced regular expression. This is primarily useful when you want to change a single line in a file only. See the `ansible.builtin.replace` module if you want to change multiple, similar lines or check `ansible.builtin.blockinfile` if you want to insert/update/remove a block of lines in a file. For other cases, see the `ansible.builtin.copy` or `ansible.builtin.template` modules.

const ListenPortsFactsName = "listen_ports_facts"

Gather facts on processes listening on TCP and UDP ports using the `netstat` or `ss` commands. This module currently supports Linux only.

const LldpName = "lldp"

Reads data out of `lldpctl`.

const LocaleGenName = "locale_gen"

Manages locales in Debian and Ubuntu systems.

const LogentriesName = "logentries"

Sends logs to LogEntries in realtime.

const LvgName = "lvg"

This module creates, removes or resizes volume groups.

const LvgRenameName = "lvg_rename"

This module renames volume groups using the `vgchange` command.

const MacportsName = "macports"

Manages MacPorts packages (ports).

const MakeName = "make"

Run targets in a Makefile.

const MasName = "mas"

Installs, uninstalls and updates macOS applications from the Mac App Store using the `mas-cli`.

const ModprobeName = "modprobe"

Load or unload kernel modules.

const MountFactsName = "mount_facts"

Retrieve information about mounts from preferred sources and filter the results based on the filesystem type and device.

const MountName = "mount"

This module controls active and configured mount points in `/etc/fstab`.

const NictagadmName = "nictagadm"

Create or delete nic tags on SmartOS systems.

const NmcliName = "nmcli"

Manage the network devices. Create, modify and manage various connection and device type, for example `ethernet`, `team`, `bond`, `vlan` and so on. On CentOS 8 and Fedora >=29 like systems, the requirements can be met by installing the following packages: NetworkManager. On CentOS 7 and Fedora <=28 like systems, the requirements can be met by installing the following packages: NetworkManager-tui. On Ubuntu and Debian like systems, the requirements can be met by installing the following packages: network-manager. On openSUSE, the requirements can be met by installing the following packages: NetworkManager.

const NpmName = "npm"

Manage node.js packages with Node Package Manager (npm).

const NsupdateName = "nsupdate"

Create, update and remove DNS records using DDNS updates.

const OpkgName = "opkg"

Manages ipk packages for OpenWrt and Openembedded/Yocto based Linux distributions.

const PackageFactsName = "package_facts"

Return information about installed packages as facts.

const PackageName = "package"

This modules manages packages on a target without specifying a package manager module (like `ansible.builtin.dnf`, `ansible.builtin.apt`, ...). It is convenient to use in an heterogeneous environment of machines without having to create a specific task for each package manager. `ansible.builtin.package` calls behind the module for the package manager used by the operating system discovered by the module `ansible.builtin.setup`. If `ansible.builtin.setup` was not yet run, `ansible.builtin.package` will run it. This module acts as a proxy to the underlying package manager module. While all arguments will be passed to the underlying module, not all modules support the same arguments. This documentation only covers the minimum intersection of module arguments that all packaging modules support. For Windows targets, use the `ansible.windows.win_package` module instead.

const PacmanName = "pacman"

Manage packages with the `pacman` package manager, which is used by Arch Linux and its variants.

const PamLimitsName = "pam_limits"

The `community.general.pam_limits` module modifies PAM limits. The default file is `/etc/security/limits.conf`. For the full documentation, see `man 5 limits.conf`.

const PamdName = "pamd"

Edit PAM service's type, control, module path and module arguments. In order for a PAM rule to be modified, the type, control and module_path must match an existing rule. See man(5) pam.d for details.

const PartedName = "parted"

This module allows configuring block device partition using the `parted` command line tool. For a full description of the fields and the options check the GNU parted manual.

const PatchName = "patch"

Apply patch files using the GNU patch tool.

const PearName = "pear"

Manage PHP packages with the pear package manager.

const PidsName = "pids"

Retrieves a list of PIDs of given process name in Ansible controller/controlled machines. Returns an empty list if no process in that name exists.

const PingName = "ping"

A trivial test module, this module always returns `pong` on successful contact. It does not make sense in playbooks, but it is useful from `/usr/bin/ansible` to verify the ability to login and that a usable Python is configured. This is NOT ICMP ping, this is just a trivial test module that requires Python on the remote-node. For Windows targets, use the `ansible.windows.win_ping` module instead. For Network targets, use the `ansible.netcommon.net_ping` module instead.

const PipName = "pip"

Manage Python library dependencies. To use this module, one of the following keys is required: `name` or `requirements`.

const PipPackageInfoName = "pip_package_info"

Return information about installed pip packages.

const PipxInfoName = "pipx_info"

Retrieve details about Python applications installed in isolated virtualenvs using pipx.

const PipxName = "pipx"

Manage Python applications installed in isolated virtualenvs using pipx.

const Pkg5Name = "pkg5"

IPS packages are the native packages in Solaris 11 and higher.

const Pkg5PublisherName = "pkg5_publisher"

IPS packages are the native packages in Solaris 11 and higher. This modules will configure which publishers a client will download IPS packages from.

const PkginName = "pkgin"

The standard package manager for SmartOS, but also usable on NetBSD or any OS that uses `pkgsrc`. (Home: `http://pkgin.net/`).

const PkgngName = "pkgng"

Manage binary packages for FreeBSD using `pkgng` which is available in versions after 9.0.

const PkgutilName = "pkgutil"

This module installs, updates and removes packages from the OpenCSW project for Solaris. Unlike the `community.general.svr4pkg` module, it will resolve and download dependencies. See `https://www.opencsw.org/` for more information about the project.

const PmemName = "pmem"

This module allows Configuring Intel Optane Persistent Memory modules (PMem) using `ipmctl` and `ndctl` command line tools.

const PnpmName = "pnpm"

Manage Node.js packages with the `pnpm package manager, https://pnpm.io/`.

const PortageName = "portage"

Manages Gentoo packages.

const PortinstallName = "portinstall"

Manage packages for FreeBSD using `portinstall`.

const ReplaceName = "replace"

This module will replace all instances of a pattern within a file. It is up to the user to maintain idempotence by ensuring that the same pattern would never match any replacements made.

const RhelFactsName = "rhel_facts"

Compatibility layer for using the `ansible.builtin.package` module for rpm- ostree based systems via setting the `pkg_mgr` fact correctly.

const RhelRpmOstreeName = "rhel_rpm_ostree"

Compatibility layer for using the "package" module for RHEL for Edge systems utilizing the RHEL System Roles.

const RhsmReleaseName = "rhsm_release"

Sets or unsets the release version used by RHSM repositories.

const RhsmRepositoryName = "rhsm_repository"

Manage (Enable/Disable) RHSM repositories to the Red Hat Subscription Management entitlement platform using the `subscription-manager` command.

const RpmKeyName = "rpm_key"

Adds or removes `rpm --import` a gpg key to your rpm database.

const RpmOstreePkgName = "rpm_ostree_pkg"

Install or uninstall overlay additional packages using `rpm-ostree` command.

const RpmOstreeUpgradeName = "rpm_ostree_upgrade"

Manage an rpm-ostree upgrade transactions.

const SebooleanName = "seboolean"

Toggles SELinux booleans.

const SelinuxName = "selinux"

Configures the SELinux mode and policy. A reboot may be required after usage. Ansible will not issue this reboot but will let you know when it is required.

const SelinuxPermissiveName = "selinux_permissive"

Add and remove a domain from the list of permissive domains.

const SeportName = "seport"

Manages SELinux network port type definitions.

const ServiceName = "service"

Controls services on remote hosts. Supported init systems include BSD init, OpenRC, SysV, Solaris SMF, systemd, upstart. This module acts as a proxy to the underlying service manager module. While all arguments will be passed to the underlying module, not all modules support the same arguments. This documentation only covers the minimum intersection of module arguments that all service manager modules support. This module is a proxy for multiple more specific service manager modules (such as `ansible.builtin.systemd` and `ansible.builtin.sysvinit`). This allows management of a heterogeneous environment of machines without creating a specific task for each service manager. The module to be executed is determined by the `use` option, which defaults to the service manager discovered by `ansible.builtin.setup`. If `ansible.builtin.setup` was not yet run, this module may run it. For Windows targets, use the `ansible.windows.win_service` module instead.

const SetupName = "setup"

This module is automatically called by playbooks to gather useful variables about remote hosts that can be used in playbooks. It can also be executed directly by `/usr/bin/ansible` to check what variables are available to a host. Ansible provides many `facts` about the system, automatically. This module is also supported for Windows targets.

const ShutdownName = "shutdown"

Shut downs a machine.

const SlackpkgName = "slackpkg"

Manage binary packages for Slackware using `slackpkg` which is available in versions after 12.2.

const SlurpName = "slurp"

This module works like `ansible.builtin.fetch`. It is used for fetching a base64- encoded blob containing the data in a remote file. This module is also supported for Windows targets.

const SmartosImageInfoName = "smartos_image_info"

Retrieve information about all installed images on SmartOS.

const SnapAliasName = "snap_alias"

Manages snaps aliases.

const SorceryName = "sorcery"

Manages "spells" on Source Mage GNU/Linux using `sorcery` toolchain.

const StatName = "stat"

Retrieves facts for a file similar to the Linux/Unix `stat` command. For Windows targets, use the `ansible.windows.win_stat` module instead.

const SubversionName = "subversion"

Deploy given repository URL / revision to dest. If dest exists, update to the specified revision, otherwise perform a checkout.

const Svr4pkgName = "svr4pkg"

Manages SVR4 packages on Solaris 10 and 11. These were the native packages on Solaris <= 10 and are available as a legacy feature in Solaris 11. Note that this is a very basic packaging system. It will not enforce dependencies on install or remove.

const SwdepotName = "swdepot"

Will install, upgrade and remove packages with swdepot package manager (HP- UX).

const SwupdName = "swupd"

Manages updates and bundles with the swupd bundle manager, which is used by the Clear Linux Project for Intel Architecture.

const SynchronizeName = "synchronize"

`ansible.posix.synchronize` is a wrapper around `rsync` to make common tasks in your playbooks quick and easy. It is run and originates on the local host where Ansible is being run. Of course, you could just use the `ansible.builtin.command` action to call `rsync` yourself, but you also have to add a fair number of boilerplate options and host facts. This module is not intended to provide access to the full power of `rsync`, but does make the most common invocations easier to implement. You `still` may need to call `rsync` directly via `ansible.builtin.command` or `ansible.builtin.shell` depending on your use case.

const SysctlName = "sysctl"

This module manipulates sysctl entries and optionally performs a `/sbin/sysctl -p` after changing them.

const SyspatchName = "syspatch"

Manage OpenBSD system patches using syspatch.

const SysrcName = "sysrc"

Manages `/etc/rc.conf` for FreeBSD.

const SystemdCredsDecryptName = "systemd_creds_decrypt"

This module decrypts input using `systemd`'s `systemd-creds decrypt`.

const SystemdCredsEncryptName = "systemd_creds_encrypt"

This module encrypts input using `systemd`'s `systemd-creds encrypt`.

const SystemdInfoName = "systemd_info"

This module gathers info about systemd units (services, targets, sockets, mounts, timers). Timer units are supported since community.general 10.5.0. It runs `systemctl list-units` (or processes selected units) and collects properties for each unit using `systemctl show`. In case a unit has multiple properties with the same name, only the value of the first one will be collected. Even if a unit has a R`units.loadstate` of `not-found` or `masked`, it is returned, but only with the minimal properties (R`units.name`, R`units.loadstate`, R`units.activestate`, R`units.substate`). When `unitname` and `extra_properties` are used, the module first checks if the unit exists, then check if properties exist. If not, the module fails. When `unitname` is used with wildcard expressions, the module checks for units that match the indicated expressions, if units are not present for all the indicated expressions, the module fails.

const SystemdServiceName = "systemd_service"

Controls systemd units (services, timers, and so on) on remote hosts. `ansible.builtin.systemd` is renamed to `ansible.builtin.systemd_service` to better reflect the scope of the module. `ansible.builtin.systemd` is kept as an alias for backward compatibility.

const SysvinitName = "sysvinit"

Controls services on target hosts that use the SysV init system.

const TempfileName = "tempfile"

The `ansible.builtin.tempfile` module creates temporary files and directories. `mktemp` command takes different parameters on various systems, this module helps to avoid troubles related to that. Files/directories created by module are accessible only by creator. In case you need to make them world-accessible you need to use `ansible.builtin.file` module. For Windows targets, use the `ansible.windows.win_tempfile` module instead.

const TimezoneName = "timezone"

This module configures the timezone setting, both of the system clock and of the hardware clock. If you want to set up the NTP, use `ansible.builtin.service` module. It is recommended to restart `crond` after changing the timezone, otherwise the jobs may run at the wrong time. Several different tools are used depending on the OS/Distribution involved. For Linux it can use `timedatectl` or edit `/etc/sysconfig/clock` or `/etc/timezone` and `hwclock`. On SmartOS, `sm-set-timezone`, for macOS, `systemsetup`, for BSD, `/etc/localtime` is modified. On AIX, `chtz` is used. Make sure that the zoneinfo files are installed with the appropriate OS package, like `tzdata` (usually always installed, when not using a minimal installation like Alpine Linux). Windows and HPUX are not supported, please let us know if you find any other OS/distro in which this fails.

const UnarchiveName = "unarchive"

The `ansible.builtin.unarchive` module unpacks an archive. It will not unpack a compressed file that does not contain an archive. By default, it will copy the source file from the local system to the target before unpacking. Set `remote_src=yes` to unpack an archive which already exists on the target. If checksum validation is desired, use `ansible.builtin.get_url` or `ansible.builtin.uri` instead to fetch the file and set `remote_src=yes`. For Windows targets, use the `community.windows.win_unzip` module instead.

const UriName = "uri"

Interacts with HTTP and HTTPS web services and supports Digest, Basic and WSSE HTTP authentication mechanisms. For Windows targets, use the `ansible.windows.win_uri` module instead.

const UrpmiName = "urpmi"

Manages packages with `urpmi` (such as for Mageia or Mandriva).

const UsbFactsName = "usb_facts"

Allows retrieving information about available USB devices through `lsusb`.

const UserName = "user"

Manage user accounts and user attributes. For Windows targets, use the `ansible.windows.win_user` module instead.

const VdoName = "vdo"

This module controls the VDO dedupe and compression device. VDO, or Virtual Data Optimizer, is a device-mapper target that provides inline block-level deduplication, compression, and thin provisioning capabilities to primary storage.

const WaitForName = "wait_for"

You can wait for a set amount of time `timeout`, this is the default if nothing is specified or just `timeout` is specified. This does not produce an error. Waiting for a port to become available is useful for when services are not immediately available after their init scripts return which is true of certain Java application servers. It is also useful when starting guests with the `community.libvirt.virt` module and needing to pause until they are ready. This module can also be used to wait for a regex match a string to be present in a file. In Ansible 1.6 and later, this module can also be used to wait for a file to be available or absent on the filesystem. In Ansible 1.8 and later, this module can also be used to wait for active connections to be closed before continuing, useful if a node is being rotated out of a load balancer pool. For Windows targets, use the `ansible.windows.win_wait_for` module instead.

const XattrName = "xattr"

Manages filesystem user defined extended attributes. Requires that extended attributes are enabled on the target filesystem and that the `setfattr`/`getfattr` utilities are present.

const XbpsName = "xbps"

Manage packages with the XBPS package manager.

const XdgMimeName = "xdg_mime"

This module allows configuring the default handler for specific MIME types when you use applications that rely on XDG.

const XfconfInfoName = "xfconf_info"

This module allows retrieving Xfce 4 configurations with the help of `xfconf- query`.

const XfconfName = "xfconf"

This module allows for the manipulation of Xfce 4 Configuration with the help of `xfconf-query`.

const XfsQuotaName = "xfs_quota"

Configure quotas on XFS filesystems. Before using this module /etc/projects and /etc/projid need to be configured.

const XmlName = "xml"

A CRUD-like interface to managing bits of XML files.

const YarnName = "yarn"

Manage Node.js packages with the Yarn package manager `https://yarnpkg.com/`. Note that at the moment, this module `only works with Yarn Classic`.

const YumRepositoryName = "yum_repository"

Add or remove YUM repositories in RPM-based Linux distributions. If you wish to update an existing repository definition use `community.general.ini_file` instead.

const YumVersionlockName = "yum_versionlock"

This module adds installed packages to yum versionlock to prevent the package(s) from being updated.

const ZfsDelegateAdminName = "zfs_delegate_admin"

Manages ZFS file system delegated administration permissions, which allow unprivileged users to perform ZFS operations normally restricted to the superuser. See the `zfs allow` section of `zfs(1M\`) for detailed explanations of options. This module attempts to adhere to the behavior of the command line tool as much as possible.

const ZfsFactsName = "zfs_facts"

Gather facts from ZFS dataset properties.

const ZfsName = "zfs"

Manages ZFS file systems, volumes, clones and snapshots.

const ZpoolFactsName = "zpool_facts"

Gather facts from ZFS pool properties.

const ZypperName = "zypper"

Manage packages on SUSE and openSUSE using the zypper and rpm tools. Also supports transactional updates, by running zypper inside `/sbin/transactional-update --continue --drop-if-no-change --quiet run`.