Ansible devel - en to ja translation catalogue (3116 entries)

en: Ansible concepts
ja: Ansible の概念

en: These concepts are common to all uses of Ansible. You need to understand them to use Ansible for any kind of automation. This basic introduction provides the background you need to follow the rest of the User Guide.
ja: この概念は、Ansible のすべての用途に共通しています。あらゆる種類の自動化のために Ansible を使用するには、これらを理解する必要があります。この基本的な紹介は、本ガイドの内容を理解するのに必要な背景を説明します。

en: Control node
ja: コントロールノード

en: Any machine with Ansible installed. You can run Ansible commands and playbooks by invoking the ``ansible`` or ``ansible-playbook`` command from any control node. You can use any computer that has a Python installation as a control node - laptops, shared desktops, and servers can all run Ansible. However, you cannot use a Windows machine as a control node. You can have multiple control nodes.
ja: Ansible がインストールされているマシン。任意のコントロールノードから ``ansible`` コマンドまたは ``ansible-playbook`` コマンドを呼び出すことで、Ansible コマンドおよび Playbook を実行できます。Python がインストールされているコンピューターであれば、ラップトップ、共有ディスクトップ、サーバーなど、どのコンピューターでも Ansible を実行することができます。ただし、Windows マシンをコントロールノードとして使用することはできません。複数のコントロールノードを持つことができます。

en: Managed nodes
ja: 管理ノード

en: The network devices (and/or servers) you manage with Ansible. Managed nodes are also sometimes called "hosts". Ansible is not installed on managed nodes.
ja: Ansible で管理するネットワークデバイス (またはサーバー)。管理ノードは「ホスト」と呼ばれることもあります。Ansible は管理ノードにインストールされません。

en: Inventory
ja: インベントリー

en: A list of managed nodes. An inventory file is also sometimes called a "hostfile". Your inventory can specify information like IP address for each managed node. An inventory can also organize managed nodes, creating and nesting groups for easier scaling. To learn more about inventory, see :ref:`the Working with Inventory<intro_inventory>` section.
ja: 管理ノードの一覧。インベントリーファイルは「ホストファイル」と呼ばれることもあります。インベントリーは、各管理ノードに対して IP アドレスなどの情報を指定できます。インベントリーは管理ノードを整理でき、スケーリングが容易になるグループの作成やネスト化が可能です。インベントリーの詳細は「:ref:`インベントリーでの作業 <intro_inventory>`」セクションを参照してください。

en: Collections
ja: コレクション

en: Collections are a distribution format for Ansible content that can include playbooks, roles, modules, and plugins. You can install and use collections through `Ansible Galaxy <https://galaxy.ansible.com>`_. To learn more about collections, see :ref:`collections`.
ja: コレクションは、Playbook、ロール、モジュール、プラグインを含む Ansible コンテンツのディストリビューション形式です。`Ansible Galaxy <https://galaxy.ansible.com>`_ でコレクションをインストールして使用することができます。コレクションの詳細は、「:ref:`collections`」を参照してください。

en: Modules
ja: モジュール

en: The units of code Ansible executes. Each module has a particular use, from administering users on a specific type of database to managing VLAN interfaces on a specific type of network device. You can invoke a single module with a task, or invoke several different modules in a playbook. Starting in Ansible 2.10, modules are grouped in collections. For an idea of how many collections Ansible includes, take a look at the :ref:`list_of_collections`.
ja: Ansible が実行するコードの単位。各モジュールは、特定タイプのデータベースのユーザーを管理したり、特定タイプのネットワークデバイスの VLAN インターフェースを管理するなど、特定の用途に使用されます。タスクで 1 つのモジュールを起動したり、Playbook で複数のモジュールを起動したりすることができます。Ansible 2.10 以降、モジュールはコレクションとしてまとめられています。Ansible に含まれるコレクションの数は、「:ref:`list_of_collections`」を参照してください。

en: Tasks
ja: タスク

en: The units of action in Ansible. You can execute a single task once with an ad hoc command.
ja: Ansible でのアクションの単位。アドホックコマンドを使用すると、単一のタスクを実行できます。

en: Playbooks
ja: Playbook

en: Ordered lists of tasks, saved so you can run those tasks in that order repeatedly. Playbooks can include variables as well as tasks. Playbooks are written in YAML and are easy to read, write, share and understand. To learn more about playbooks, see :ref:`about_playbooks`.
ja: 順番に並べられたタスクの一覧は保存されているため、その順番でタスクを繰り返し実行することができます。Playbook には、タスクだけでなく、変数も含めることができます。Playbook は YAML で記述されているため、読みやすく、書きやすく、共有しやすく、理解しやすい特徴があります。Playbook の詳細は、「:ref:`about_playbooks`」を参照してください。

en: Understanding privilege escalation: become
ja: 権限昇格の理解: become

en: Ansible uses existing privilege escalation systems to execute tasks with root privileges or with another user's permissions. Because this feature allows you to 'become' another user, different from the user that logged into the machine (remote user), we call it ``become``. The ``become`` keyword leverages existing privilege escalation tools like `sudo`, `su`, `pfexec`, `doas`, `pbrun`, `dzdo`, `ksu`, `runas`, `machinectl` and others.
ja: Ansible は既存の権限昇格システムを使用して、root 権限または別のユーザーのパーミッションでタスクを実行します。この機能を使用すると、このマシンにログインしたユーザー (リモートユーザー) とは別のユーザー「になる (become)」ことができるため、この機能は ``become`` と呼ばれています。``become`` キーワードは、`sudo`、`su`、`pfexec`、`doas`、`pbrun`、`dzdo`、`ksu`、`runas`、`machinectl` などの既存の特権昇格ツールを活用します。

en: Using become
ja: become の使用

en: You can control the use of ``become`` with play or task directives, connection variables, or at the command line. If you set privilege escalation properties in multiple ways, review the :ref:`general precedence rules<general_precedence_rules>` to understand which settings will be used.
ja: play ディレクティブまたは task ディレクティブ、接続変数、またはコマンドラインでの ``become`` の使用を制御できます。複数の方法で権限昇格プロパティーを設定する場合は、:ref:`一般的な優先順位ルール<general_precedence_rules>` を確認し、使用する設定を確認します。

en: A full list of all become plugins that are included in Ansible can be found in the :ref:`become_plugin_list`.
ja: Ansible に含まれる全 become プラグインの完全リストは、:ref:`become_plugin_list` にあります。

en: Become directives
ja: Become ディレクティブ

en: You can set the directives that control ``become`` at the play or task level. You can override these by setting connection variables, which often differ from one host to another. These variables and directives are independent. For example, setting ``become_user`` does not set ``become``.
ja: プレイまたはタスクレベルで、``become`` を制御するディレクティブを設定できます。多くの場合は、ホストごとに異なる接続変数を設定することで、これらをオーバーライドできます。これらの変数とディレクティブは独立しています。たとえば、``become_user`` に設定しても ``become`` に設定されません。

en: set to ``yes`` to activate privilege escalation.
ja: 権限昇格をアクティブにするには、``yes`` に設定します。

en: set to user with desired privileges — the user you `become`, NOT the user you login as. Does NOT imply ``become: yes``, to allow it to be set at host level. Default value is ``root``.
ja: 希望する権限を持つユーザーに設定します。ログインしたユーザーではなく、`become` を行ったユーザーになります。ホストレベルで設定できるようにする ``become: yes`` を意味するものではありません。デフォルト値は ``root`` です。

en: (at play or task level) overrides the default method set in ansible.cfg, set to use any of the :ref:`become_plugins`.
ja: (play レベルまたは task レベルで)、ansible.cfg に設定されたデフォルトのメソッドをオーバーライドし、:ref:`become_plugins` を使用するよう設定します。

en: (at play or task level) permit the use of specific flags for the tasks or role. One common use is to change the user to nobody when the shell is set to nologin. Added in Ansible 2.2.
ja: (play レベルまたは task レベルで) タスクまたはロールに特定のフラグの使用を許可します。一般的な使い方としては、シェルが nologin に設定されているときに、ユーザーを nobody に変更するのが一般的な方法です。Ansible 2.2 で追加されました。

en: For example, to manage a system service (which requires ``root`` privileges) when connected as a non-``root`` user, you can use the default value of ``become_user`` (``root``):
ja: たとえば、``root`` 以外のユーザーとして接続する際にシステムサービスを管理する (``root`` 権限が必要) には、``become_user`` (``root``) のデフォルト値を使用できます。

en: To run a command as the ``apache`` user:
ja: ``apache`` ユーザーとしてコマンドを実行するには、次を実行します。

en: To do something as the ``nobody`` user when the shell is nologin:
ja: シェルが nologin の場合に ``nobody`` ユーザーとして操作を行う場合は、次を実行します。

en: To specify a password for sudo, run ``ansible-playbook`` with ``--ask-become-pass`` (``-K`` for short). If you run a playbook utilizing ``become`` and the playbook seems to hang, most likely it is stuck at the privilege escalation prompt. Stop it with `CTRL-c`, then execute the playbook with ``-K`` and the appropriate password.
ja: sudo のパスワードを指定するには、``ansible-playbook`` を ``--ask-become-pass`` (略して ``-K``) と一緒に実行します。``become`` を使用して Playbook を実行し、Playbook がハングしているように見える場合は、ほとんどの場合、特権昇格のプロンプトで止まっています。`CTRL-c` で停止させてから、``-K`` と適切なパスワードで Playbook を実行してください。

en: Become connection variables
ja: Become 接続変数

en: You can define different ``become`` options for each managed node or group. You can define these variables in inventory or use them as normal variables.
ja: 管理対象ノードまたはグループごとに異なる ``become`` オプションを定義できます。これらの変数はインベントリーで定義するか、通常の変数として使用できます。

en: overrides the ``become`` directive, decides if privilege escalation is used or not.
ja: ``become`` ディレクティブを上書きします。権限のエスカレーションが使用されるかどうかを指定します。

en: which privilege escalation method should be used
ja: 使用する権限昇格方法です。

en: set the user you become through privilege escalation; does not imply ``ansible_become: yes``
ja: 権限昇格で become を行うユーザーを設定します。``ansible_become: yes`` を意味するものではありません。

en: set the privilege escalation password. See :ref:`playbooks_vault` for details on how to avoid having secrets in plain text
ja: 権限昇格パスワードを設定します。平文での秘密の使用を回避する方法は、「:ref:`playbooks_vault`」を参照してください。

en: determines if Ansible should try to ``chgrp`` its temporary files to a group if ``setfacl`` and ``chown`` both fail. See `Risks of becoming an unprivileged user`_ for more information. Added in version 2.10.
ja: ``setfacl`` と ``chown`` の両方が失敗した場合に、Ansible が一時ファイルをグループに ``chgrp`` しようとするかどうかを決定します。詳細は「`非特権ユーザーになるリスク`_」を参照してください。バージョン 2.10 で追加されました。

en: For example, if you want to run all tasks as ``root`` on a server named ``webserver``, but you can only connect as the ``manager`` user, you could use an inventory entry like this:
ja: たとえば、すべてのタスクを ``webserver`` という名前のサーバーで ``root`` として実行することを望み、``manager`` ユーザーとしてのみ接続できる場合は、以下のようなインベントリーエントリーを使用できます。

en: The variables defined above are generic for all become plugins but plugin specific ones can also be set instead. Please see the documentation for each plugin for a list of all options the plugin has and how they can be defined. A full list of become plugins in Ansible can be found at :ref:`become_plugins`.
ja: 上記の変数はすべての become プラグインに汎用的なものですが、代わりにプラグイン固有の変数を設定することもできます。そのプラグインが持つすべてのオプションとその定義方法の一覧は、各プラグインのドキュメントを参照してください。Ansible における become プラグインの完全なリストは :ref:`become_plugins` を参照してください。

en: Become command-line options
ja: Become コマンドラインオプション

en: ask for privilege escalation password; does not imply become will be used. Note that this password will be used for all hosts.
ja: 権限昇格パスワードを要求します。これは。必ずしも become が使用されるとは限りません。このパスワードはすべてのホストで使用されることに注意してください。

en: run operations with become (no password implied)
ja: become で操作を実行します (パスワードがないことを示しています)。

en: privilege escalation method to use (default=sudo), valid choices: [ sudo | su | pbrun | pfexec | doas | dzdo | ksu | runas | machinectl ]
ja: 使用する特権昇格方法 (デフォルトは sudo)。有効な選択肢は、[ sudo | su | pbrun | pfexec | doas | dzdo | ksu | runas | machinectl ] となります。

en: run operations as this user (default=root), does not imply --become/-b
ja: このユーザー (デフォルトは root) として操作を実行します。--become/-b を意味するものではありません。

en: Risks and limitations of become
ja: become のリスクおよび制限

en: Although privilege escalation is mostly intuitive, there are a few limitations on how it works.  Users should be aware of these to avoid surprises.
ja: 特権の昇格はほとんど直感的ですが、それがどのように機能するかについては、いくつかの制限があります。問題が発生しないように、これらの点に注意する必要があります。

en: Risks of becoming an unprivileged user
ja: 非特権ユーザーになる (become) リスク

en: Ansible modules are executed on the remote machine by first substituting the parameters into the module file, then copying the file to the remote machine, and finally executing it there.
ja: Ansible モジュールは、まずモジュールファイルにパラメーターを代入し、次にそのファイルをリモートマシンにコピーし、最後にそこで実行することで、リモートマシン上で実行されます。

en: Everything is fine if the module file is executed without using ``become``, when the ``become_user`` is root, or when the connection to the remote machine is made as root. In these cases Ansible creates the module file with permissions that only allow reading by the user and root, or only allow reading by the unprivileged user being switched to.
ja: モジュールファイルが ``become`` を使用せずに、``become_user`` が root の場合や、リモートマシンへの接続が root として行われる場合、すべてのことは問題ありません。このような場合、Ansible は、ユーザーおよび root による読み取りのみを許可するパーミッション、または切り替え先の非特権ユーザーの読み取りのみを許可するパーミッションを持つモジュールファイルを作成します。

en: However, when both the connection user and the ``become_user`` are unprivileged, the module file is written as the user that Ansible connects as (the ``remote_user``), but the file needs to be readable by the user Ansible is set to ``become``. The details of how Ansible solves this can vary based on platform. However, on POSIX systems, Ansible solves this problem in the following way:
ja: ただし、接続ユーザーと ``become_user`` の両方が特権を持たない場合、モジュールファイルは Ansible が接続するユーザー (``remote_user``) として記述されますが、Ansible が ``become`` に設定されているユーザーがファイルを読み取れる必要があります。Ansible がこれをプラットフォーム別に解決する方法の詳細は次のとおりですが、POSIX システムでは、Ansible がこの問題を解決します。

en: First, if :command:`setfacl` is installed and available in the remote ``PATH``, and the temporary directory on the remote host is mounted with POSIX.1e filesystem ACL support, Ansible will use POSIX ACLs to share the module file with the second unprivileged user.
ja: まず、リモート ``PATH`` に :command:`setfacl` がインストールされ、利用可能な場合は、リモートホストの一時ディレクトリーが POSIX.1e ファイルシステム ACL サポートでマウントされている場合、Ansible は POSIX ACL を使用して 2 つの非特権ユーザーとモジュールファイルを共有します。

en: Next, if POSIX ACLs are **not** available or :command:`setfacl` could not be run, Ansible will attempt to change ownership of the module file using :command:`chown` for systems which support doing so as an unprivileged user.
ja: 次に、POSIX ACL が利用 **できない** か、:command:`setfacl` を実行できない場合、Ansible は、特権のないユーザーとして対応するシステムの :command:`chown` を使用してモジュールファイルの所有権を変更しようとします。

en: New in Ansible 2.11, at this point, Ansible will try :command:`chmod +a` which is a macOS-specific way of setting ACLs on files.
ja: Ansible 2.11 の新機能として、Ansible は、ファイルに ACL を設定する際に macOS 固有の方法で :command:`chmod +a` を試行します。

en: New in Ansible 2.10, if all of the above fails, Ansible will then check the value of the configuration setting ``ansible_common_remote_group``. Many systems will allow a given user to change the group ownership of a file to a group the user is in. As a result, if the second unprivileged user (the ``become_user``) has a UNIX group in common with the user Ansible is connected as (the ``remote_user``), and if ``ansible_common_remote_group`` is defined to be that group, Ansible can try to change the group ownership of the module file to that group by using :command:`chgrp`, thereby likely making it readable to the ``become_user``.
ja: Ansible 2.10 の新機能で、上記のすべてが失敗すると、Ansible は構成設定 ``ansible_common_remote_group`` の値を確認します。多くのシステムでは、特定のユーザーが、ファイルのグループ所有権を、所属するグループに変更できます。その結果、2 番目の非特権ユーザー (``become_user``) に、Ansible が (``remote_user``として) 接続するユーザーに共通する UNIX グループがあり、``ansible_common_remote_group`` がそのグループとして定義されている場合は、 :command:`chgrp` を使用してモジュールファイルのグループ所有権をそのグループに変更しようとすることができます。したがって、``become_user`` が読みるようになる可能性があります。

en: At this point, if ``ansible_common_remote_group`` was defined and a :command:`chgrp` was attempted and returned successfully, Ansible assumes (but, importantly, does not check) that the new group ownership is enough and does not fall back further. That is, Ansible **does not check** that the ``become_user`` does in fact share a group with the ``remote_user``; so long as the command exits successfully, Ansible considers the result successful and does not proceed to check ``allow_world_readable_tmpfiles`` per below.
ja: この時点で、``ansible_common_remote_group`` が定義され、 :command:`chgrp` が試行されて正常に返された場合、Ansible は新しいグループの所有権で十分であると仮定し (ただし、重要なことですが、確認はしません)、それ以上はフォールバックしません。つまり、``become_user`` が実際に ``remote_user`` とグループを共有しているかどうかは **確認しません**。コマンドが正常に終了する限り、Ansible はその結果を成功とみなし、以下の ``allow_world_readable_tmpfiles`` のチェックには進みません。

en: If ``ansible_common_remote_group`` is **not** set and the chown above it failed, or if ``ansible_common_remote_group`` *is* set but the :command:`chgrp` (or following group-permissions :command:`chmod`) returned a non-successful exit code, Ansible will lastly check the value of ``allow_world_readable_tmpfiles``. If this is set, Ansible will place the module file in a world-readable temporary directory, with world-readable permissions to allow the ``become_user`` (and incidentally any other user on the system) to read the contents of the file. **If any of the parameters passed to the module are sensitive in nature, and you do not trust the remote machines, then this is a potential security risk.**
ja: ``ansible_common_remote_group`` が **設定されておらず**、そこでの chown が失敗した場合、または ``ansible_common_remote_group`` *が* 設定されているが :command:`chgrp` (またはそれに続くグループパーミッションの :command:`chmod`) が成功しない終了コードを返した場合、Ansible は最後に ``allow_world_readable_tmpfiles`` の値を確認します。この値が設定されていると、Ansible はモジュールファイルを誰もが読める一時ディレクトリーに置き、``become_user`` (およびシステム上の他のユーザー) がファイルの内容を読めるように、誰もが読み取り可能なパーミッションを設定します。**モジュールに渡されるパラメーターに機密性があり、リモートマシンを信用していない場合、これは潜在的なセキュリティーリスクとなります。**

en: Once the module is done executing, Ansible deletes the temporary file.
ja: モジュールの実行が完了すると、Ansible は一時ファイルを削除します。

en: Several ways exist to avoid the above logic flow entirely:
ja: 上記のロジックフローを完全に回避する方法はいくつかあります。

en: Use `pipelining`.  When pipelining is enabled, Ansible does not save the module to a temporary file on the client.  Instead it pipes the module to the remote python interpreter's stdin. Pipelining does not work for python modules involving file transfer (for example: :ref:`copy <copy_module>`, :ref:`fetch <fetch_module>`, :ref:`template <template_module>`), or for non-python modules.
ja: `pipelining` を使用します。パイプラインを有効にすると、Ansible はモジュールをクライアント上の一時ファイルに保存しません。代わりに、モジュールをリモートの python インタープリターの標準入力にパイプします。パイプラインは、ファイル転送を伴う python モジュール (例: :ref:`copy <copy_module>`、:ref:`fetch <fetch_module>`、:ref:`template <template_module>`) や、python 以外のモジュールでは機能しません。

en: Avoid becoming an unprivileged user.  Temporary files are protected by UNIX file permissions when you ``become`` root or do not use ``become``.  In Ansible 2.1 and above, UNIX file permissions are also secure if you make the connection to the managed machine as root and then use ``become`` to access an unprivileged account.
ja: 非特権ユーザーは使用しないでください。root に ``become`` した場合、または ``become`` を使用しない場合は、UNIX ファイルの権限で保護されます。Ansible 2.1 以降では、UNIX ファイルのパーミッションは、root として管理マシンに接続し、権限のないアカウントにアクセスするには、``become`` を使用しても保護されます。

en: Although the Solaris ZFS filesystem has filesystem ACLs, the ACLs are not POSIX.1e filesystem acls (they are NFSv4 ACLs instead).  Ansible cannot use these ACLs to manage its temp file permissions so you may have to resort to ``allow_world_readable_tmpfiles`` if the remote machines use ZFS.
ja: Solaris ZFS ファイルシステムにはファイルシステム ACL がありますが、ACL は POSIX.1e ファイルシステムの acl ではありません (正しくは NFSv4 ACL)。Ansible はこれらの ACL を使用してその一時ファイルのパーミッションを管理できないため、リモートマシンが ZFS を使用している場合は ``allow_world_readable_tmpfiles`` を再処理しないといけない場合があります。

en: Ansible makes it hard to unknowingly use ``become`` insecurely. Starting in Ansible 2.1, Ansible defaults to issuing an error if it cannot execute securely with ``become``. If you cannot use pipelining or POSIX ACLs, must connect as an unprivileged user, must use ``become`` to execute as a different unprivileged user, and decide that your managed nodes are secure enough for the modules you want to run there to be world readable, you can turn on ``allow_world_readable_tmpfiles`` in the :file:`ansible.cfg` file.  Setting ``allow_world_readable_tmpfiles`` will change this from an error into a warning and allow the task to run as it did prior to 2.1.
ja: Ansible では、知らずに ``become`` を安全でない状態で使用することは困難です。Ansible 2.1 以降、Ansible は ``become`` で安全に実行できない場合は、デフォルトでエラーを発行するようになっています。パイプラインや POSIX ACL を使用できず、非特権ユーザーとして接続しなければならず、``become`` を使用して別の非特権ユーザーとして実行しなければならず、管理対象のノードが、そこで実行したいモジュールが誰でも読むことができる程度に安全であると判断した場合は、:file:`ansible.cfg` ファイルで ``allow_world_readable_tmpfiles`` を有効にすることができます。``allow_world_readable_tmpfiles`` を設定すると、これがエラーから警告に変わり、2.1 以前のようにタスクを実行できるようになります。

en: Ansible 2.10 introduces the above-mentioned ``ansible_common_remote_group`` fallback. As mentioned above, if enabled, it is used when ``remote_user`` and ``become_user`` are both unprivileged users. Refer to the text above for details on when this fallback happens.
ja: Ansible 2.10 では、上記の ``ansible_common_remote_group`` フォールバックが導入されました。上記のように、有効になっていると、``remote_user`` と ``become_user`` の両方が非特権ユーザーである場合に使用されます。このフォールバックが発生するときの詳細は、上記のテキストを参照してください。

en: As mentioned above, if ``ansible_common_remote_group`` and ``allow_world_readable_tmpfiles`` are both enabled, it is unlikely that the world-readable fallback will ever trigger, and yet Ansible might still be unable to access the module file. This is because after the group ownership change is successful, Ansible does not fall back any further, and also does not do any check to ensure that the ``become_user`` is actually a member of the "common group". This is a design decision made by the fact that doing such a check would require another round-trip connection to the remote machine, which is a time-expensive operation. Ansible does, however, emit a warning in this case.
ja: 上記のように、``ansible_common_remote_group`` と ``allow_world_readable_tmpfiles`` の両方が有効になると、誰でも読み取り可能なフォールバックがトリガーされず、Ansible がまだモジュールファイルにアクセスできない可能性があります。これは、グループの所有権変更が成功した後に、Ansible はこれ以上フォールバックせず、``become_user`` が実際には「共通グループ」のメンバーであることを確認するためのチェックが行われないためですこれは、このようなチェックを行うと、リモートマシンへの別のラウンドトリップ接続が必要になり、時間のかかる操作になってしまうことを考慮した設計上の決定です。しかし、Ansible はこの場合、警告を発します。

en: Not supported by all connection plugins
ja: すべての接続プラグインでサポートされない

en: Privilege escalation methods must also be supported by the connection plugin used. Most connection plugins will warn if they do not support become. Some will just ignore it as they always run as root (jail, chroot, and so on).
ja: 特権昇格の方法は、使用する接続プラグインがサポートしている必要があります。ほとんどの接続プラグインは、become をサポートしていないと警告を表示します。一部の接続プラグインでは、常に root として実行されるため (jail、chroot など)、無視されます。

en: Only one method may be enabled per host
ja: ホストごとに有効にできる方法は 1 つだけ

en: Methods cannot be chained. You cannot use ``sudo /bin/su -`` to become a user, you need to have privileges to run the command as that user in sudo or be able to su directly to it (the same for pbrun, pfexec or other supported methods).
ja: メソッドを連鎖させることはできません。``sudo /bin/su -`` を使用してユーザーになる (become) ことはできません。そのユーザーとして sudo でコマンドを実行するか、直接 su できるような権限が必要です (pbrun、pfexec、その他のサポートされている方法も同様です)。

en: Privilege escalation must be general
ja: 特権昇格は一般的なものにすること

en: You cannot limit privilege escalation permissions to certain commands. Ansible does not always use a specific command to do something but runs modules (code) from a temporary file name which changes every time.  If you have '/sbin/service' or '/bin/chmod' as the allowed commands this will fail with ansible as those paths won't match with the temporary file that Ansible creates to run the module. If you have security rules that constrain your sudo/pbrun/doas environment to running specific command paths only, use Ansible from a special account that does not have this constraint, or use :ref:`ansible_tower` to manage indirect access to SSH credentials.
ja: 特権昇格の許可を特定のコマンドに限定することはできません。Ansible は常に特定のコマンドを使用して何かを行うわけではなく、毎回変更される一時ファイル名からモジュール (コード) を実行します。許可されるコマンドとして「/sbin/service」や「/bin/chmod」を指定した場合、これらのパスは Ansible がモジュールを実行するために作成する一時ファイルと一致しないため、Ansible では失敗します。sudo/pbrun/doas 環境で特定のコマンドパスしか実行できないようなセキュリティールールがある場合は、この制約を受けない特別なアカウントで Ansible を使用するか、:ref:`ansible_tower` を使用して SSH 認証情報への間接的なアクセスを管理してください。

en: May not access environment variables populated by pamd_systemd
ja: pamd_systemd が設定する環境変数にアクセスできない場合

en: For most Linux distributions using ``systemd`` as their init, the default methods used by ``become`` do not open a new "session", in the sense of systemd. Because the ``pam_systemd`` module will not fully initialize a new session, you might have surprises compared to a normal session opened through ssh: some environment variables set by ``pam_systemd``, most notably ``XDG_RUNTIME_DIR``, are not populated for the new user and instead inherited or just emptied.
ja: ``systemd`` を init として使用しているほとんどの Linux ディストリビューションでは、``become`` が使用するデフォルトの方法では、systemd の意味での新しい「セッション」を開くことができません。``pam_systemd`` モジュールは新しいセッションを完全には初期化しないため、ssh で開いた通常のセッションと比べて驚くことがあるかもしれません。``pam_systemd`` によって設定されたいくつかの環境変数、特に ``XDG_RUNTIME_DIR`` は新しいユーザーには設定されず、代わりに継承されたり、単に空になったりします。

en: This might cause trouble when trying to invoke systemd commands that depend on ``XDG_RUNTIME_DIR`` to access the bus:
ja: このため、バスへのアクセスを ``XDG_RUNTIME_DIR`` に依存する systemd コマンドを呼び出す際に問題が発生する可能性があります。

en: To force ``become`` to open a new systemd session that goes through ``pam_systemd``, you can use ``become_method: machinectl``.
ja: ``become`` に、``pam_systemd`` を通して新しい systemd セッションを開くために、``become_method: machinectl`` を使用することができます。

en: For more information, see `this systemd issue <https://github.com/systemd/systemd/issues/825#issuecomment-127917622>`_.
ja: 詳細情報は、「`this systemd issue <https://github.com/systemd/systemd/issues/825#issuecomment-127917622>`_」を参照してください。

en: Become and network automation
ja: become およびネットワーク自動化

en: As of version 2.6, Ansible supports ``become`` for privilege escalation (entering ``enable`` mode or privileged EXEC mode) on all Ansible-maintained network platforms that support ``enable`` mode. Using ``become`` replaces the ``authorize`` and ``auth_pass`` options in a ``provider`` dictionary.
ja: バージョン 2.6 以降、Ansible は、``enable`` モードをサポートするすべての Ansible が保守するネットワークプラットフォームにおいて、特権昇格 (``enable`` モードまたは特権 EXEC モードへの移行) のために ``become`` をサポートしています。``become`` を使用すると、``provider`` ディクショナリーの ``authorize`` オプションおよび ``auth_pass``のオプションが置き換えられます。

en: You must set the connection type to either ``connection: ansible.netcommon.network_cli`` or ``connection: ansible.netcommon.httpapi`` to use ``become`` for privilege escalation on network devices. Check the :ref:`platform_options` documentation for details.
ja: ネットワークデバイスの特権昇格に ``become`` を使用するには、接続タイプを ``connection: ansible.netcommon.network_cli`` または ``connection: ansible.netcommon.httpapi`` のいずれかに設定する必要があります。詳細については、「:ref:`platform_options`」を確認してください。

en: You can use escalated privileges on only the specific tasks that need them, on an entire play, or on all plays. Adding ``become: yes`` and ``become_method: enable`` instructs Ansible to enter ``enable`` mode before executing the task, play, or playbook where those parameters are set.
ja: 昇格した権限は、それを必要とする特定のタスクのみ、プレイ全体でのみ、またはすべてのプレイで使用することができます。``become: yes`` と ``become_method: enable`` を追加すると、これらのパラメーターが設定されているタスク、プレイ、または Playbook を実行する前に、``enable`` モードに入るよう Ansible に指示します。

en: If you see this error message, the task that generated it requires ``enable`` mode to succeed:
ja: このエラーメッセージが表示された場合に、エラーメッセージを生成したタスクを成功させるには、``enable`` モードが必要になります。

en: To set ``enable`` mode for a specific task, add ``become`` at the task level:
ja: 特定のタスクに ``enable`` モードを設定するには、タスクレベルで ``become`` を追加します。

en: To set enable mode for all tasks in a single play, add ``become`` at the play level:
ja: 1 つのプレイのすべてのタスクに enable モードを設定するには、プレイレベルに ``become`` を追加します。

en: Setting enable mode for all tasks
ja: すべてのタスクに enable モードの設定

en: Often you wish for all tasks in all plays to run using privilege mode, that is best achieved by using ``group_vars``:
ja: すべてのプレイのすべてのタスクを特権モードで実行させたいと思うことがよくありますが、そのような場合には、``group_vars`` を使用することが最適です。

en: Passwords for enable mode
ja: enable モードのパスワード

en: If you need a password to enter ``enable`` mode, you can specify it in one of two ways:
ja: ``enable`` モードに入るパスワードが必要な場合は、以下のいずれかの方法で指定できます。

en: providing the :option:`--ask-become-pass <ansible-playbook --ask-become-pass>` command line option
ja: :option:`--ask-become-pass <ansible-playbook --ask-become-pass>` コマンドラインオプションの指定

en: setting the ``ansible_become_password`` connection variable
ja: ``ansible_become_password`` 接続変数の設定

en: As a reminder passwords should never be stored in plain text. For information on encrypting your passwords and other secrets with Ansible Vault, see :ref:`vault`.
ja: 通知パスワードは平文で保存しないでください。Ansible Vault でパスワードやその他の秘密を暗号化する方法は、「:ref:`vault`」を参照してください。

en: authorize and auth_pass
ja: authorize および auth_pass

en: Ansible still supports ``enable`` mode with ``connection: local`` for legacy network playbooks. To enter ``enable`` mode with ``connection: local``, use the module options ``authorize`` and ``auth_pass``:
ja: Ansible では、従来のネットワークの Playbook について、``connection: local`` を使用した ``enable`` モードを引き続きサポートしています。``connection: local`` で ``enable`` モードに入るには、モジュールオプション ``authorize`` および ``auth_pass`` を使用します。

en: We recommend updating your playbooks to use ``become`` for network-device ``enable`` mode consistently. The use of ``authorize`` and of ``provider`` dictionaries will be deprecated in future. Check the :ref:`platform_options` and :ref:`network_modules` documentation for details.
ja: ネットワークデバイスの ``enable`` モードに ``become`` を一貫して使用するように Playbook を更新することが推奨されます。``authorize`` および ``provider`` ディクショナリーの使用は、今後は推奨されません。詳細は、「:ref:`platform_options`」および「:ref:`network_modules`」のドキュメントを参照してください。

en: Become and Windows
ja: Become および Windows

en: Since Ansible 2.3, ``become`` can be used on Windows hosts through the ``runas`` method. Become on Windows uses the same inventory setup and invocation arguments as ``become`` on a non-Windows host, so the setup and variable names are the same as what is defined in this document.
ja: Ansible 2.3 以降、``become`` は ``runas`` メソッドを通じて Windows ホストでも使用できるようになりました。Windows 上の Become は、非 Windows ホスト上の ``become`` と同じインベントリー設定と起動引数を使用するため、設定と変数名はこのドキュメントで定義されているものと同じになります。

en: While ``become`` can be used to assume the identity of another user, there are other uses for it with Windows hosts. One important use is to bypass some of the limitations that are imposed when running on WinRM, such as constrained network delegation or accessing forbidden system calls like the WUA API. You can use ``become`` with the same user as ``ansible_user`` to bypass these limitations and run commands that are not normally accessible in a WinRM session.
ja: ``become`` は、別のユーザーの ID を装うために使用することができますが、Windows ホストではそれ以外にも使用方法があります。重要な用途の 1 つは、ネットワーク委譲の制約や、WUA API のような禁止されたシステムコールへのアクセスなど、WinRM 上で実行する際に課される制限の一部を回避することです。``become`` を ``ansible_user`` と同じユーザーで使用すると、これらの制限を回避して、WinRM セッションでは通常アクセスできないコマンドを実行することができます。

en: Administrative rights
ja: 管理者権限

en: Many tasks in Windows require administrative privileges to complete. When using the ``runas`` become method, Ansible will attempt to run the module with the full privileges that are available to the remote user. If it fails to elevate the user token, it will continue to use the limited token during execution.
ja: Windows の多くのタスクを完了するには、管理者権限が必要です。``runas`` の become メソッドを使用すると、Ansible はリモートユーザーが使用できる全権限でモジュールの実行を試みます。ユーザートークンの昇格に失敗すると、実行中に制限されたトークンを引き続き使用します。

en: A user must have the ``SeDebugPrivilege`` to run a become process with elevated privileges. This privilege is assigned to Administrators by default. If the debug privilege is not available, the become process will run with a limited set of privileges and groups.
ja: ユーザーは、昇格された権限で become プロセスを実行するには、``SeDebugPrivilege`` が必要です。この権限はデフォルトで管理者に割り当てられます。デバッグ権限が利用できない場合、become プロセスは、限られた一連の特権およびグループで実行されます。

en: To determine the type of token that Ansible was able to get, run the following task:
ja: Ansible が取得できたトークンの種類を確認するには、以下のタスクを実行します。

en: The output will look something similar to the below:
ja: 出力は以下のようになります。

en: Under the ``label`` key, the ``account_name`` entry determines whether the user has Administrative rights. Here are the labels that can be returned and what they represent:
ja: ``label`` キーにおいて、``account_name`` エントリーは、ユーザーに管理権限があるかどうかを判断します。ここでは、返すことができるラベルと、そのラベルが表す内容を紹介します。

en: ``Medium``: Ansible failed to get an elevated token and ran under a limited token. Only a subset of the privileges assigned to user are available during the module execution and the user does not have administrative rights.
ja: ``Medium``: Ansible が昇格したトークンの取得に失敗し、制限付きのトークンで実行されました。モジュールの実行中に、ユーザーに割り当てられた特権のサブセットのみが利用可能で、ユーザーは管理者権限を持っていません。

en: ``High``: An elevated token was used and all the privileges assigned to the user are available during the module execution.
ja: ``High``: 昇格されたトークンが使用され、ユーザーに割り当てられたすべての特権は、モジュールの実行時に利用できます。

en: ``System``: The ``NT AUTHORITY\System`` account is used and has the highest level of privileges available.
ja: ``System``: ``NT AUTHORITY\System`` アカウントが使用され、利用可能な最高レベルの特権が付与されます。

en: The output will also show the list of privileges that have been granted to the user. When the privilege value is ``disabled``, the privilege is assigned to the logon token but has not been enabled. In most scenarios these privileges are automatically enabled when required.
ja: 出力には、ユーザーに付与される権限の一覧が表示されます。権限の値が ``disabled`` の場合、特権はログオントークンに割り当てられますが、有効になっていません。ほとんどのシナリオでは、これらの特権は必要に応じて自動的に有効になります。

en: If running on a version of Ansible that is older than 2.5 or the normal ``runas`` escalation process fails, an elevated token can be retrieved by:
ja: Ansible のバージョンが 2.5 よりも古い場合や、通常の ``runas`` のエスカレーションプロセスが失敗した場合は、昇格したトークンを以下の方法で取得できます。

en: Set the ``become_user`` to ``System`` which has full control over the operating system.
ja: ``become_user`` を、オペレーティングシステムを完全にコントロールする ``System`` に設定します。

en: Grant ``SeTcbPrivilege`` to the user Ansible connects with on WinRM. ``SeTcbPrivilege`` is a high-level privilege that grants full control over the operating system. No user is given this privilege by default, and care should be taken if you grant this privilege to a user or group. For more information on this privilege, please see `Act as part of the operating system <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn221957(v=ws.11)>`_. You can use the below task to set this privilege on a Windows host:
ja: Ansible が WinRM で接続するユーザーに ``SeTcbPrivilege`` を付与します。``SeTcbPrivilege`` は、オペレーティングシステムに対する完全な制御を付与する高レベルの特権です。デフォルトでは、この特権は指定されていません。この特権をユーザーまたはグループに付与する場合は注意が必要です。この特権の詳細は、「`Act as part of the operating system <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn221957(v=ws.11)>`_」を参照してください。以下のタスクを使用して、Windows ホストでこの特権を設定できます。

en: Turn UAC off on the host and reboot before trying to become the user. UAC is a security protocol that is designed to run accounts with the ``least privilege`` principle. You can turn UAC off by running the following tasks:
ja: そのユーザーになる (become) 前に、ホストで UAC をオフにし、再起動します。UAC は、``least privilege`` プリンシパルでアカウントを実行するように設計されたセキュリティープロトコルです。以下のタスクを実行して UAC をオフにすることができます。

en: Granting the ``SeTcbPrivilege`` or turning UAC off can cause Windows security vulnerabilities and care should be given if these steps are taken.
ja: ``SeTcbPrivilege`` を付与するか UAC をオフにすると、Windows のセキュリティー上の脆弱性を引き起こす可能性があるため、このような手順を実行する場合は注意が必要です。

en: Local service accounts
ja: ローカルサービスアカウント

en: Prior to Ansible version 2.5, ``become`` only worked on Windows with a local or domain user account. Local service accounts like ``System`` or ``NetworkService`` could not be used as ``become_user`` in these older versions. This restriction has been lifted since the 2.5 release of Ansible. The three service accounts that can be set under ``become_user`` are:
ja: Ansible バージョン 2.5 より前のバージョンでは、``become`` は、Windows でローカルまたはドメインのユーザーアカウントでのみ動作していました。``System`` や ``NetworkService`` などのローカルサービスアカウントは、これらの旧バージョンでは ``become_user`` として使用できません。この制限は、Ansible 2.5 のリリース以降は解除されました。``become_user`` に設定できる 3 つのサービスアカウントは以下のとおりです。

en: System
ja: システム

en: Because local service accounts do not have passwords, the ``ansible_become_password`` parameter is not required and is ignored if specified.
ja: ローカルサービスアカウントはパスワードを持たないため、``ansible_become_password`` パラメーターは必須ではなく、指定しても無視されます。

en: Become without setting a password
ja: パスワードを設定しない Become

en: As of Ansible 2.8, ``become`` can be used to become a Windows local or domain account without requiring a password for that account. For this method to work, the following requirements must be met:
ja: Ansible 2.8 では、Windows のローカルまたはドメインアカウントになるために、そのアカウントのパスワードがなくても ``become`` を使用することができます。この方法を行うには、以下の要件を満たす必要があります。

en: The connection user has the ``SeDebugPrivilege`` privilege assigned
ja: 接続ユーザーに ``SeDebugPrivilege`` 権限が割り当てられている

en: The connection user is part of the ``BUILTIN\Administrators`` group
ja: 接続ユーザーが ``BUILTIN\Administrators`` グループに属している

en: The ``become_user`` has either the ``SeBatchLogonRight`` or ``SeNetworkLogonRight`` user right
ja: ``become_user`` に、``SeBatchLogonRight`` または``SeNetworkLogonRight`` のユーザー権限がある

en: Using become without a password is achieved in one of two different methods:
ja: パスワードなしの become は、次のいずれかの方法で使用できます。

en: Duplicating an existing logon session's token if the account is already logged on
ja: そのアカウントがすでにログオンしている場合は、既存のログオンセッションのトークンを複製する

en: Using S4U to generate a logon token that is valid on the remote host only
ja: S4U を使用してリモートホストでのみ有効なログイントークンを生成する

en: In the first scenario, the become process is spawned from another logon of that user account. This could be an existing RDP logon, console logon, but this is not guaranteed to occur all the time. This is similar to the ``Run only when user is logged on`` option for a Scheduled Task.
ja: 最初のシナリオでは、そのユーザーアカウントの別のログオンから become プロセスを起動します。これは既存の RDP ログイン、コンソールログオンですが、これは常に発生するとは限りません。これは、スケジュール済みタスクの ``Run only when user is logged on`` オプションと類似しています。

en: In the case where another logon of the become account does not exist, S4U is used to create a new logon and run the module through that. This is similar to the ``Run whether user is logged on or not`` with the ``Do not store password`` option for a Scheduled Task. In this scenario, the become process will not be able to access any network resources like a normal WinRM process.
ja: become アカウントの別のログオンが存在しない場合は、S4U を使用して新しいログオンを作成し、それを介してモジュールを実行します。これは、スケジュール済みタスクの ``Do not store password`` オプションを持つ ``Run whether user is logged on or not`` と似ています。このシナリオでは、become プロセスは通常の WinRM プロセスなどのネットワークリソースにアクセスできません。

en: To make a distinction between using become with no password and becoming an account that has no password make sure to keep ``ansible_become_password`` as undefined or set ``ansible_become_password:``.
ja: パスワードなしで become を使用することと、パスワードがないアカウントになる (become) ことを区別するには、``ansible_become_password`` を undefined にしておくか、``ansible_become_password:`` を設定してください。

en: Because there are no guarantees an existing token will exist for a user when Ansible runs, there's a high change the become process will only have access to local resources. Use become with a password if the task needs to access network resources
ja: Ansible の実行時に既存のトークンがユーザーに存在するという保証がないため、become プロセスがローカルリソースにのみアクセスできます。タスクがネットワークリソースにアクセスする必要がある場合は、パスワードで become を使用します。

en: Accounts without a password
ja: パスワードのないアカウント

en: As a general security best practice, you should avoid allowing accounts without passwords.
ja: セキュリティーに関する一般的なベストプラクティスとして、パスワードのないアカウントを許可しないでください。

en: Ansible can be used to become a Windows account that does not have a password (like the ``Guest`` account). To become an account without a password, set up the variables like normal but set ``ansible_become_password: ''``.
ja: Ansible を使用して、パスワードがない Windows アカウントになります (``Guest`` アカウントなど)。パスワードのないアカウントになるには、通常どおり変数を設定しますが、``ansible_become_password: ''`` を設定します。

en: Before become can work on an account like this, the local policy `Accounts: Limit local account use of blank passwords to console logon only <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/jj852174(v=ws.11)>`_ must be disabled. This can either be done through a Group Policy Object (GPO) or with this Ansible task:
ja: このようなアカウントで become を有効にする前に、ローカルポリシー `Accounts: Limit local account use of blank passwords to console logon only <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/jj852174(v=ws.11)>`_ を無効にする必要があります。これは Group Policy Object (GPO) またはこの Ansible タスクで実行できます。

en: This is only for accounts that do not have a password. You still need to set the account's password under ``ansible_become_password`` if the become_user has a password.
ja: これは、パスワードがないアカウント専用です。become_user にパスワードがある場合は、``ansible_become_password`` でアカウントのパスワードを設定する必要があります。

en: Become flags for Windows
ja: Windows での Become フラグ

en: Ansible 2.5 added the ``become_flags`` parameter to the ``runas`` become method. This parameter can be set using the ``become_flags`` task directive or set in Ansible's configuration using ``ansible_become_flags``. The two valid values that are initially supported for this parameter are ``logon_type`` and ``logon_flags``.
ja: Ansible 2.5 では、``become_flags`` パラメーターを become メソッド ``runas`` に追加しました。このパラメーターは、``become_flags`` タスクディレクティブを使用するか、``ansible_become_flags`` を使用して Ansible の設定で設定できます。このパラメーターで最初にサポートされる 2 つの有効な値は ``logon_type`` と ``logon_flags`` です。

en: These flags should only be set when becoming a normal user account, not a local service account like LocalSystem.
ja: これらのフラグは、LocalSystem などのローカルサービスアカウントではなく、通常のユーザーアカウントになる (become) 場合にのみ設定する必要があります。

en: The key ``logon_type`` sets the type of logon operation to perform. The value can be set to one of the following:
ja: 鍵 ``logon_type`` は、実行するログオン操作のタイプを設定します。値は以下のいずれかに設定できます。

en: ``interactive``: The default logon type. The process will be run under a context that is the same as when running a process locally. This bypasses all WinRM restrictions and is the recommended method to use.
ja: ``interactive``: デフォルトのログオンタイプ。プロセスは、ローカルでプロセスを実行するときと同じコンテキストで実行されます。これにより、すべての WinRM 制限が回避され、推奨される方法です。

en: ``batch``: Runs the process under a batch context that is similar to a scheduled task with a password set. This should bypass most WinRM restrictions and is useful if the ``become_user`` is not allowed to log on interactively.
ja: ``batch``: パスワードセットを使用してスケジュールされたタスクに似たバッチコンテキストでプロセスを実行します。これにより、ほとんどの WinRM 制限を回避する必要があり、``become_user`` が対話的にログインできない場合に役立ちます。

en: ``new_credentials``: Runs under the same credentials as the calling user, but outbound connections are run under the context of the ``become_user`` and ``become_password``, similar to ``runas.exe /netonly``. The ``logon_flags`` flag should also be set to ``netcredentials_only``. Use this flag if the process needs to access a network resource (like an SMB share) using a different set of credentials.
ja: ``new_credentials``: 呼び出し元ユーザーと同じ認証情報の下で実行されますが、発信側の接続は ``runas.exe /netonly`` と同様に``become_user`` と ``become_password`` のコンテキストの下で実行されます。``logon_flags`` フラグは、``netcredentials_only`` にも設定する必要があります。このフラグは、プロセスが異なる認証情報セットを使用してネットワークリソース (SMB 共有など) にアクセスする必要がある場合に使用します。

en: ``network``: Runs the process under a network context without any cached credentials. This results in the same type of logon session as running a normal WinRM process without credential delegation, and operates under the same restrictions.
ja: ``network``: キャッシュされた認証情報なしで、ネットワークコンテキストでプロセスを実行します。これにより、認証情報の委譲を使用せずに通常の WinRM プロセスを実行するのと同じ種類のログオンセッションが実行され、同じ制限で動作します。

en: ``network_cleartext``: Like the ``network`` logon type, but instead caches the credentials so it can access network resources. This is the same type of logon session as running a normal WinRM process with credential delegation.
ja: ``network_cleartext``: ``network`` ログオンタイプなのですが、代わりに認証情報をキャッシュするため、ネットワークリソースにアクセスできます。これは、認証情報の委譲を使用して通常の WinRM プロセスを実行するのと同じタイプのログオンセッションです。

en: For more information, see `dwLogonType <https://docs.microsoft.com/en-gb/windows/desktop/api/winbase/nf-winbase-logonusera>`_.
ja: 詳細情報は、「`dwLogonType <https://docs.microsoft.com/en-gb/windows/desktop/api/winbase/nf-winbase-logonusera>`_」を参照してください。

en: The ``logon_flags`` key specifies how Windows will log the user on when creating the new process. The value can be set to none or multiple of the following:
ja: ``logon_flags`` キーは、新規プロセスの作成時に Windows がユーザーをログに記録する方法を指定します。この値は、以下の複数の値に設定でき、値を設定しないこともできます。

en: ``with_profile``: The default logon flag set. The process will load the user's profile in the ``HKEY_USERS`` registry key to ``HKEY_CURRENT_USER``.
ja: ``with_profile``: デフォルトのログオンフラグセット。このプロセスは、``HKEY_USERS`` レジストリーキーのユーザーのプロファイルを ``HKEY_CURRENT_USER`` に読み込みます。

en: ``netcredentials_only``: The process will use the same token as the caller but will use the ``become_user`` and ``become_password`` when accessing a remote resource. This is useful in inter-domain scenarios where there is no trust relationship, and should be used with the ``new_credentials`` ``logon_type``.
ja: ``netcredentials_only``: プロセスは呼び出し元と同じトークンを使用しますが、リモートリソースにアクセスする際には ``become_user`` と ``become_password`` を使用します。これは、信頼関係がないドメイン間シナリオで便利です。また、``new_credentials`` ``logon_type`` と共に使用する必要があります。

en: By default ``logon_flags=with_profile`` is set, if the profile should not be loaded set ``logon_flags=`` or if the profile should be loaded with ``netcredentials_only``, set ``logon_flags=with_profile,netcredentials_only``.
ja: デフォルトでは ``logon_flags=with_profile`` が設定されていますが、プロファイルを読み込む必要がない場合は ``logon_flags=`` を設定するか、``netcredentials_only`` でプロファイルを読み込む必要がある場合は``logon_flags=with_profile,netcredentials_only`` を設定してください。

en: For more information, see `dwLogonFlags <https://docs.microsoft.com/en-gb/windows/desktop/api/winbase/nf-winbase-createprocesswithtokenw>`_.
ja: 詳細情報は、「`dwLogonFlags <https://docs.microsoft.com/en-gb/windows/desktop/api/winbase/nf-winbase-createprocesswithtokenw>`_」を参照してください。

en: Here are some examples of how to use ``become_flags`` with Windows tasks:
ja: Windows タスクで ``become_flags`` を使用する例を以下に示します。

en: Limitations of become on Windows
ja: Windows における become 制限

en: Running a task with ``async`` and ``become`` on Windows Server 2008, 2008 R2 and Windows 7 only works when using Ansible 2.7 or newer.
ja: Windows Server 2008、2008 R2、Windows 7 で``async`` および ``become`` を使用してタスクを実行できるのは、Ansible 2.7 以降を使用している場合のみです。

en: By default, the become user logs on with an interactive session, so it must have the right to do so on the Windows host. If it does not inherit the ``SeAllowLogOnLocally`` privilege or inherits the ``SeDenyLogOnLocally`` privilege, the become process will fail. Either add the privilege or set the ``logon_type`` flag to change the logon type used.
ja: デフォルトでは、become ユーザーは対話型セッションでログオンするため、Windows ホストでこの権限を設定する必要があります。``SeAllowLogOnLocally`` 特権を継承しない場合、または ``SeDenyLogOnLocally`` 特権を継承する場合は become プロセスに失敗します。特権を追加するか、``logon_type`` フラグを設定して使用するログオンタイプを変更してください。

en: Prior to Ansible version 2.3, become only worked when ``ansible_winrm_transport`` was either ``basic`` or ``credssp``. This restriction has been lifted since the 2.4 release of Ansible for all hosts except Windows Server 2008 (non R2 version).
ja: Ansible バージョン 2.3 よりも前のバージョンでは、``ansible_winrm_transport`` が ``basic`` または ``credssp`` のいずれかでのみ機能していました。この制限は、Windows Server 2008 (R2 バージョン以外) を除くすべてのホストで 2.4 リリース以降に取り込まれました。

en: The Secondary Logon service ``seclogon`` must be running to use ``ansible_become_method: runas``
ja: ``ansible_become_method: runas`` を使用するには、セカンダリーログオンサービス ``seclogon`` が実行している必要があります。

en: Questions? Help? Ideas?  Stop by the list on Google Groups
ja: ご質問はございますか。サポートが必要ですか。ご提案はございますか。Google グループの一覧をご覧ください。

en: #ansible IRC chat channel
ja: IRC チャットチャンネル (#ansible)

en: Using collections
ja: コレクションの使用

en: Collections are a distribution format for Ansible content that can include playbooks, roles, modules, and plugins. As modules move from the core Ansible repository into collections, the module documentation will move to the :ref:`collections pages <list_of_collections>`.
ja: コレクションは、Playbook、ロール、モジュール、プラグインなどの Ansible コンテンツの配布形式です。モジュールがコアの Ansible リポジトリーからコレクションに移動したため、モジュールのドキュメントも :ref:`コレクションページ <list_of_collections>` に移動します。

en: You can install and use collections through `Ansible Galaxy <https://galaxy.ansible.com>`_.
ja: `Ansible Galaxy <https://galaxy.ansible.com>`_ を使用してコレクションをインストールして使用できます。

en: For details on how to *develop* collections see :ref:`developing_collections`.
ja: *develop* コレクションの使用方法は、「:ref:`developing_collections`」を参照してください。

en: For the current development status of Collections and FAQ see `Ansible Collections Community Guide <https://github.com/ansible-collections/overview/blob/main/README.rst>`_.
ja: コレクションおよび FAQ の現在の開発ステータスは、「`Ansible コレクションのコミュニティーガイド <https://github.com/ansible-collections/overview/blob/main/README.rst>`_」を参照してください。

en: Installing collections
ja: コレクションのインストール

en: If you install a collection manually as described in this paragraph, the collection will not be upgraded automatically when you upgrade the ``ansible`` package or ``ansible-core``.
ja: この段落で説明されているようにコレクションを手動でインストールした場合には、``ansible`` パッケージまたは ``ansible-core`` をアップグレードすると、コレクションは自動的にアップグレードされません。

en: Installing collections with ``ansible-galaxy``
ja: ``ansible-galaxy`` でコレクションのインストール

en: By default, ``ansible-galaxy collection install`` uses https://galaxy.ansible.com as the Galaxy server (as listed in the :file:`ansible.cfg` file under :ref:`galaxy_server`). You do not need any further configuration.
ja: デフォルトでは、``ansible-galaxy collection install`` は https://galaxy.ansible.com を Galaxy サーバーとして使用します (:ref:`galaxy_server` の :file:`ansible.cfg` ファイルに記載)。追加設定は必要ありません。

en: See :ref:`Configuring the ansible-galaxy client <galaxy_server_config>` if you are using any other Galaxy server, such as Red Hat Automation Hub.
ja: Red Hat Automation Hub などの他の Galaxy サーバーを使用している場合は、「:ref:`Configuring the ansible-galaxy client <galaxy_server_config>`」を参照してください。

en: To install a collection hosted in Galaxy:
ja: Galaxy でホストされるコレクションをインストールするには、以下を実行します。

en: To upgrade a collection to the latest available version from the Galaxy server you can use the ``--upgrade`` option:
ja: コレクションを Galaxy サーバーから利用可能な最新バージョンにアップグレードするには、``--upgrade`` オプションを使用します。

en: You can also directly use the tarball from your build:
ja: ビルドから tarball を直接使用することもできます。

en: You can build and install a collection from a local source directory. The ``ansible-galaxy`` utility builds the collection using the ``MANIFEST.json`` or ``galaxy.yml`` metadata in the directory.
ja: ローカルソースディレクトリーからコレクションを構築してインストールできます。``ansible-galaxy`` ユーティリティーは、ディレクトリー内の ``MANIFEST.json`` または ``galaxy.yml`` メタデータを使用してコレクションを構築します。

en: You can also install multiple collections in a namespace directory.
ja: 名前空間ディレクトリーに複数のコレクションをインストールすることもできます。

en: The install command automatically appends the path ``ansible_collections`` to the one specified  with the ``-p`` option unless the parent directory is already in a folder called ``ansible_collections``.
ja: install コマンドは、親ディレクトリーが ``ansible_collections`` ディレクトリーに含まれている場合を除き、``-p`` オプションで指定したパスに、パス ``ansible_collections`` を自動的に追加します。

en: When using the ``-p`` option to specify the install path, use one of the values configured in :ref:`COLLECTIONS_PATHS`, as this is where Ansible itself will expect to find collections. If you don't specify a path, ``ansible-galaxy collection install`` installs the collection to the first path defined in :ref:`COLLECTIONS_PATHS`, which by default is ``~/.ansible/collections``
ja: ``-p`` オプションを使用してインストールパスを指定する場合は、Ansible 自体がコレクションを見つけることが予想される場所であるため、:ref:`COLLECTIONS_PATHS` に設定された値のいずれかを使用します。パスを指定しないと、``ansible-galaxy collection install`` は :ref:`COLLECTIONS_PATHS` で定義されている最初のパスにコレクションをインストールします。これは、デフォルトでは ``~/.ansible/collections`` です。

en: You can also keep a collection adjacent to the current playbook, under a ``collections/ansible_collections/`` directory structure.
ja: また、``collections/ansible_collections/`` ディレクトリー構造の下で、コレクションを現在の Playbook の横に維持することもできます。

en: See :ref:`collection_structure` for details on the collection directory structure.
ja: コレクションディレクトリー構造の詳細は、「:ref:`collection_structure`」を参照してください。

en: Installing an older version of a collection
ja: 古いバージョンのコレクションのインストール

en: You can only have one version of a collection installed at a time. By default ``ansible-galaxy`` installs the latest available version. If you want to install a specific version, you can add a version range identifier. For example, to install the 1.0.0-beta.1 version of the collection:
ja: 一度にインストールするコレクションのバージョンは 1 つだけです。デフォルトでは、``ansible-galaxy`` により利用可能な最新バージョンがインストールされます。特定のバージョンをインストールする場合は、バージョン範囲識別子を追加できます。たとえば、コレクションの 1.0.0-beta.1 バージョンをインストールするには、以下を実行します。

en: You can specify multiple range identifiers separated by ``,``. Use single quotes so the shell passes the entire command, including ``>``, ``!``, and other operators, along. For example, to install the most recent version that is greater than or equal to 1.0.0 and less than 2.0.0:
ja: ``,`` で区切って複数の範囲識別子を指定できます。シェルが、``>``、``!``、およびその他の演算子を含むコマンド全体を渡すように、一重引用符を使用します。たとえば、1.0.0 以上 2.0.0 未満の最新バージョンをインストールするには、次を実行します。

en: Ansible will always install the most recent version that meets the range identifiers you specify. You can use the following range identifiers:
ja: Ansible は、指定する範囲識別子を満たす最新バージョンを常にインストールします。以下の範囲識別子を使用できます。

en: ``*``: The most recent version. This is the default.
ja: ``*``: 最新バージョンです。これがデフォルトです。

en: ``!=``: Not equal to the version specified.
ja: ``!=``: 指定されたバージョンと同等ではありません。

en: ``==``: Exactly the version specified.
ja: ``==``: 指定されたバージョンそのものになります。

en: ``>=``: Greater than or equal to the version specified.
ja: ``>=``: 指定されたバージョン以上になります。

en: ``>``: Greater than the version specified.
ja: ``>``: 指定されたバージョンよりも大きくなります。

en: ``<=``: Less than or equal to the version specified.
ja: ``<=``: 指定されたバージョン以下になります。

en: ``<``: Less than the version specified.
ja: ``<``: 指定されたバージョンよりも小さくなります。

en: By default ``ansible-galaxy`` ignores pre-release versions. To install a pre-release version, you must use the ``==`` range identifier to require it explicitly.
ja: デフォルトでは、``ansible-galaxy`` はリリース前のバージョンを無視します。リリース前のバージョンをインストールするには、``==`` 範囲識別子を使用して明示的に要求する必要があります。

en: Installing a collection from a git repository
ja: git リポジトリーからのコレクションのインストール

en: You can install a collection in a git repository by providing the URI to the repository instead of a collection name or path to a ``tar.gz`` file. The collection must contain a ``galaxy.yml`` or ``MANIFEST.json`` file, which will be used to generate the would-be collection artifact data from the directory. The URI should be prefixed with ``git+`` (or with ``git@`` to use a private repository with ssh authentication) and optionally supports a comma-separated `git commit-ish <https://git-scm.com/docs/gitglossary#def_commit-ish>`_ version (for example, a commit or tag).
ja: コレクション名または ``tar.gz`` ファイルへのパスではなく、リポジトリーに URI を提供することにより、git リポジトリーにコレクションをインストールできます。コレクションには、``galaxy.yml`` ファイルまたは ``MANIFEST.json`` ファイルが必要です。このコレクションは、ディレクトリーからの will-be コレクションアーティファクトデータを生成するのに使用されます。URI の接頭辞には ``git+`` (または ssh 認証でプライベートリポジトリーを使用する ``git@``）を付け、必要に応じてコンマ区切りの `git commit-ish <https://git-scm.com/docs/gitglossary#def_commit-ish>`_ バージョン (コミットまたはタグなど) をサポートする必要があります。

en: Embedding credentials into a git URI is not secure. Make sure to use safe auth options for security reasons. For example, use `SSH <https://help.github.com/en/github/authenticating-to-github/connecting-to-github-with-ssh>`_, `netrc <https://linux.die.net/man/5/netrc>`_ or `http.extraHeader <https://git-scm.com/docs/git-config#Documentation/git-config.txt-httpextraHeader>`_/`url.<base>.pushInsteadOf <https://git-scm.com/docs/git-config#Documentation/git-config.txt-urlltbasegtpushInsteadOf>`_ in Git config to prevent your creds from being exposed in logs.
ja: 認証情報を git URI に埋め込むことは安全ではありません。セキュリティー上の理由から、安全な認証オプションを使用してください。たとえば、Git 設定の `SSH <https://help.github.com/en/github/authenticating-to-github/connecting-to-github-with-ssh>`_、`netrc <https://linux.die.net/man/5/netrc>`_、または `http.extraHeader <https://git-scm.com/docs/git-config#Documentation/git-config.txt-httpextraHeader>`_/`url.<base>.pushInsteadOf <https://git-scm.com/docs/git-config#Documentation/git-config.txt-urlltbasegtpushInsteadOf>`_ で、クレジットがログに公開されないようにします。

en: In a ``requirements.yml`` file, you can also use the ``type`` and ``version`` keys in addition to using the ``git+repo,version`` syntax for the collection name.
ja: ``requirements.yml`` ファイルでは、コレクション名の ``git+repo,version`` 構文を使用する他に、``type`` キーおよび ``version`` キーを使用することもできます。

en: Git repositories can be used for collection dependencies as well. This can be helpful for local development and testing but built/published artifacts should only have dependencies on other artifacts.
ja: git リポジトリーはコレクションの依存関係にも使用できます。これは、ローカル開発およびテストに役立ちますが、ビルド/公開されたアーティファクトには他のアーティファクトへの依存関係のみが必要です。

en: Default repository search locations
ja: デフォルトのリポジトリー検索の場所

en: There are two paths searched in a repository for collections by default.
ja: デフォルトでは、コレクション用のリポジトリーで 2 つのパスが検索されます。

en: The first is the ``galaxy.yml`` or ``MANIFEST.json`` file in the top level of the repository path. If the file exists it's used as the collection metadata and the individual collection will be installed.
ja: 1 つ目は、リポジトリーパスの最上位にある ``galaxy.yml`` ファイルまたは ``MANIFEST.json`` ファイルです。ファイルが存在する場合は、コレクションのメタデータとして使用され、個々のコレクションがインストールされます。

en: The second is a ``galaxy.yml`` or ``MANIFEST.json`` file in each directory in the repository path (one level deep). In this scenario, each directory with a metadata file is installed as a collection.
ja: 2 つ目は、リポジトリーパス (1 レベルの深さ) の各ディレクトリーの ``galaxy.yml`` ファイルまたは ``MANIFEST.json`` ファイルです。ここでは、メタデータファイルが含まれる各ディレクトリーがコレクションとしてインストールされます)。

en: Specifying the location to search for collections
ja: コレクションを検索する場所の指定

en: If you have a different repository structure or only want to install a subset of collections, you can add a fragment to the end of your URI (before the optional comma-separated version) to indicate which path ansible-galaxy should inspect for metadata file(s). The path should be a directory to a collection or multiple collections (rather than the path to a ``galaxy.yml`` file or ``MANIFEST.json`` file).
ja: 異なるリポジトリー構造がある場合や、コレクションのサブセットのみをインストールする場合は、URI の最後にフラグメントを追加して (任意のコンマ区切りバージョンの前)、ansible-galaxy がメタデータファイルを調べるパスを示すことができます。パスは、(``MANIFEST.json`` ファイルまたは ``galaxy.yml`` ファイルへのパスではなく) コレクションまたは複数のコレクションへのディレクトリーである必要があります。

en: Install multiple collections with a requirements file
ja: 要件ファイルを使用した複数のコレクションのインストール

en: You can also setup a ``requirements.yml`` file to install multiple collections in one command. This file is a YAML file in the format:
ja: ``requirements.yml`` ファイルを設定して、1 つのコマンドで複数のコレクションをインストールすることもできます。このファイルは、以下の形式の YAML ファイルです。

en: The supported keys for collection requirement entries are ``name``, ``version``, ``source``, and ``type``.
ja: コレクション要件エントリーでサポートされるキーは ``name``、``version``、``source``、および ``type`` です。

en: The ``version`` key can take in the same range identifier format documented above. If you're installing a collection from a git repository instead of a built collection artifact, the ``version`` key refers to a `git commit-ish <https://git-scm.com/docs/gitglossary#def_commit-ish>`_.
ja: ``version`` キーは、上記の範囲識別子の形式を取ることができます。ビルドコレクションアーティファクトではなく git リポジトリーからコレクションをインストールする場合は、``version`` キーは `git commit-ish <https://git-scm.com/docs/gitglossary#def_commit-ish>`_ を参照します。

en: The ``type`` key can be set to ``galaxy``, ``url``, ``file``, and ``git``. If ``type`` is omitted, the ``name`` key is used to implicitly determine the source of the collection.
ja: ``type`` キーは ``galaxy``、``url``、``file``、および ``git`` に設定できます。``type`` を省略すると、``name`` キーを使用してコレクションのソースを暗黙的に決定します。

en: Roles can also be specified and placed under the ``roles`` key. The values follow the same format as a requirements file used in older Ansible releases.
ja: ロールは、``roles`` キーの下に指定して配置することもできます。この値は、古い Ansible リリースで使用される要件ファイルと同じ形式に従います。

en: To install both roles and collections at the same time with one command, run the following:
ja: 1 つのコマンドで、ロールとコレクションを同時にインストールするには、以下のコマンドを実行します。

en: Running ``ansible-galaxy collection install -r`` or ``ansible-galaxy role install -r`` will only install collections, or roles respectively.
ja: ``ansible-galaxy collection install -r`` または ``ansible-galaxy role install -r`` を実行すると、それぞれコレクションまたはロールがインストールされます。

en: Installing both roles and collections from the same requirements file will not work when specifying a custom collection or role install path. In this scenario the collections will be skipped and the command will process each like ``ansible-galaxy role install`` would.
ja: カスタムコレクションまたはロールインストールパスを指定する場合は、同じ要件ファイルからロールとコレクションの両方をインストールすることはできません。今回の例では、コレクションは省略され、コマンドは ``ansible-galaxy role install`` のように処理されます。

en: Downloading a collection for offline use
ja: オフラインで使用するコレクションのダウンロード

en: To download the collection tarball from Galaxy for offline use:
ja: オフラインで使用するために、コレクション tarball を Galaxy からダウンロードするには、以下を行います。

en: Navigate to the collection page.
ja: コレクションページに移動します。

en: Click on :guilabel:`Download tarball`.
ja: :guilabel:`Download tarball` をクリックします。

en: You may also need to manually download any dependent collections.
ja: また、依存するコレクションを手動でダウンロードする必要がある場合があります。

en: Configuring the ``ansible-galaxy`` client
ja: ``ansible-galaxy`` クライアントの設定

en: By default, ``ansible-galaxy`` uses https://galaxy.ansible.com as the Galaxy server (as listed in the :file:`ansible.cfg` file under :ref:`galaxy_server`).
ja: デフォルトでは、``ansible-galaxy`` は https://galaxy.ansible.com を Galaxy サーバーとして使用します (:ref:`galaxy_server` の :file:`ansible.cfg` ファイルに記載）。

en: You can use either option below to configure ``ansible-galaxy collection`` to use other servers (such as Red Hat Automation Hub or a custom Galaxy server):
ja: 以下のオプションを使用して、他のサーバー (Red Hat Automation Hub、カスタムの Galaxy サーバーなど) を使用するように ``ansible-galaxy collection`` を設定できます。

en: Set the server list in the :ref:`galaxy_server_list` configuration option in :ref:`ansible_configuration_settings_locations`.
ja: 「:ref:`ansible_configuration_settings_locations`」の「:ref:`galaxy_server_list`」設定オプションにサーバーリストを設定します。

en: Use the ``--server`` command line argument to limit to an individual server.
ja: ``--server`` コマンドライン引数を使用して、個々のサーバーに制限します。

en: To configure a Galaxy server list in ``ansible.cfg``:
ja: ``ansible.cfg`` で Galaxy サーバー一覧を設定するには、以下を行います。

en: Add the ``server_list``  option under the ``[galaxy]`` section to one or more server names.
ja: ``server_list`` セクションの ``[galaxy]`` オプションを 1 つ以上のサーバー名に追加します。

en: Create a new section for each server name.
ja: 各サーバー名に新しいセクションを作成します。

en: Set the ``url`` option for each server name.
ja: 各サーバー名に ``url`` オプションを設定します。

en: Optionally, set the API token for each server name. Go to https://galaxy.ansible.com/me/preferences and click :guilabel:`Show API key`.
ja: 必要に応じて、各サーバー名の API トークンを設定します。https://galaxy.ansible.com/me/preferences に移動し、guilabel:`Show API key` をクリックします。

en: The ``url`` option for each server name must end with a forward slash ``/``. If you do not set the API token in your Galaxy server list, use the ``--api-key`` argument to pass in the token to  the ``ansible-galaxy collection publish`` command.
ja: 各サーバー名の ``url`` オプションは、スラッシュ ``/`` で終了する必要があります。Galaxy サーバー一覧の API トークンを設定しない場合は、``--api-key`` 引数を使用してトークンを ``ansible-galaxy collection publish`` コマンドに渡します。

en: For Automation Hub, you additionally need to:
ja: Automation Hub の場合には、さらに以下の操作が必要です。

en: Set the ``auth_url`` option for each server name.
ja: 各サーバー名に ``auth_url`` オプションを設定します。

en: Set the API token for each server name. Go to https://cloud.redhat.com/ansible/automation-hub/token/ and click ::guilabel:`Get API token` from the version dropdown to copy your API token.
ja: 各サーバー名の API トークンを設定します。https://cloud.redhat.com/ansible/automation-hub/token/ に、バージョンドロップダウンリストから ::guilabel:`Get API token` をクリックして API トークンをコピーします。

en: The following example shows how to configure multiple servers:
ja: 以下の例は、複数のサーバーを設定する方法を示しています。

en: You can use the ``--server`` command line argument to select an explicit Galaxy server in the ``server_list`` and the value of this argument should match the name of the server. To use a server not in the server list, set the value to the URL to access that server (all servers in the server list will be ignored). Also you cannot use the ``--api-key`` argument for any of the predefined servers. You can only use the ``api_key`` argument if you did not define a server list or if you specify a URL in the ``--server`` argument.
ja: ``--server`` コマンドライン引数を使用して ``server_list`` で明示的な Galaxy サーバーを選択し、この引数の値はサーバー名と一致する必要があります。サーバー一覧にないサーバーを使用する場合は、そのサーバーにアクセスする URL に値を設定します (サーバーリスト内のすべてのサーバーは無視されます)。また、事前定義されたサーバーのいずれかに ``--api-key`` 引数を使用することはできません。サーバーの一覧を定義していない場合、または ``--server`` に URL を指定した場合限り、``api_key`` 引数を使用できます。

en: **Galaxy server list configuration options**
ja: **Galaxy サーバー一覧設定オプション**

en: The :ref:`galaxy_server_list` option is a list of server identifiers in a prioritized order. When searching for a collection, the install process will search in that order, for example, ``automation_hub`` first, then ``my_org_hub``, ``release_galaxy``, and finally ``test_galaxy`` until the collection is found. The actual Galaxy instance is then defined under the section ``[galaxy_server.{{ id }}]`` where ``{{ id }}`` is the server identifier defined in the list. This section can then define the following keys:
ja: :ref:`galaxy_server_list` オプションは、優先順位が付けられたサーバー識別子の一覧です。コレクションを検索する場合、インストールプロセスは次の順序で検索します。たとえば、``automation_hub`` を検索してから、``my_org_hub``、``release_galaxy``、最後に ``test_galaxy`` で、コレクションが見つかるまで行います。次に、実際の Galaxy インスタンスが ``[galaxy_server.{{ id }}]`` セクションで定義され。ここでは、``{{ id }}`` は、一覧で定義されているサーバー識別子です。このセクションでは、次のキーを定義できます。

en: ``url``: The URL of the Galaxy instance to connect to. Required.
ja: ``url``: 接続する Galaxy インスタンスの URL。必須。

en: ``token``: An API token key to use for authentication against the Galaxy instance. Mutually exclusive with ``username``.
ja: ``token``: Galaxy インスタンスに対する認証に使用する API トークンキー。``username`` と相互に排他的です。

en: ``username``: The username to use for basic authentication against the Galaxy instance. Mutually exclusive with ``token``.
ja: ``username``: Galaxy インスタンスに対する Basic 認証に使用するユーザー名。``token`` と相互に排他的です。

en: ``password``: The password to use, in conjunction with ``username``, for basic authentication.
ja: ``password``: Basic 認証に使用するパスワード。``username`` と併用します。

en: ``auth_url``: The URL of a Keycloak server 'token_endpoint' if using SSO authentication (for example, Automation Hub). Mutually exclusive with ``username``. Requires ``token``.
ja: ``auth_url``: SSO 認証 (例: Automation Hub) を使用する場合は Keycloak サーバー「token_endpoint」の URL です。``username`` と相互に排他的です。``token`` が必要です。

en: As well as defining these server options in the ``ansible.cfg`` file, you can also define them as environment variables. The environment variable is in the form ``ANSIBLE_GALAXY_SERVER_{{ id }}_{{ key }}`` where ``{{ id }}`` is the upper case form of the server identifier and ``{{ key }}`` is the key to define. For example I can define ``token`` for ``release_galaxy`` by setting ``ANSIBLE_GALAXY_SERVER_RELEASE_GALAXY_TOKEN=secret_token``.
ja: これらのサーバーオプションを ``ansible.cfg`` ファイルで定義するだけでなく、それらを環境変数として定義することもできます。環境変数は ``ANSIBLE_GALAXY_SERVER_{{ id }}_{{ key }}`` の形式です。``{{ id }}`` はサーバー識別子の大文字形式であり、``{{ key }}`` は定義するキーです。たとえば、``ANSIBLE_GALAXY_SERVER_RELEASE_GALAXY_TOKEN=secret_token`` を設定することで、``release_galaxy`` に ``token`` を定義することができます。

en: For operations that use only one Galaxy server (for example, the ``publish``, ``info``, or ``install`` commands). the ``ansible-galaxy collection`` command uses the first entry in the ``server_list``, unless you pass in an explicit server with the ``--server`` argument.
ja: Galaxy サーバー 1 つだけを使用する操作 (例: ``publish`` コマンド、``info`` コマンド、または ``install`` コマンド) の場合、``ansible-galaxy collection`` コマンドは、``--server`` 引数を使用して明示的なサーバーに渡しない限り、``server_list`` の最初のエントリーを使用します。

en: Once a collection is found, any of its requirements are only searched within the same Galaxy instance as the parent collection. The install process will not search for a collection requirement in a different Galaxy instance.
ja: コレクションが見つかると、その要件は親コレクションと同じ Galaxy インスタンス内でのみ検索されます。インストールプロセスでは、別の Galaxy インスタンスでコレクション要件を検索しません。

en: Downloading collections
ja: コレクションのダウンロード

en: To download a collection and its dependencies for an offline install, run ``ansible-galaxy collection download``. This downloads the collections specified and their dependencies to the specified folder and creates a ``requirements.yml`` file which can be used to install those collections on a host without access to a Galaxy server. All the collections are downloaded by default to the ``./collections`` folder.
ja: オフラインインストール用のコレクションとその依存関係をダウンロードするには、``ansible-galaxy collection download`` を実行します。これにより、指定されたコレクションとその依存関係を指定のディレクトリーにダウンロードして、Galaxy サーバーにアクセスせずに、ホストにこれらのコレクションをインストールするのに使用できる ``requirements.yml`` ファイルを作成します。すべてのコレクションは、デフォルトで ``./collections`` ディレクトリーにダウンロードされます。

en: Just like the ``install`` command, the collections are sourced based on the :ref:`configured galaxy server config <galaxy_server_config>`. Even if a collection to download was specified by a URL or path to a tarball, the collection will be redownloaded from the configured Galaxy server.
ja: ``install`` コマンドと同様、コレクションは :ref:`configured galaxy server config <galaxy_server_config>` に基づいて取得されます。ダウンロードするコレクションが URL や tarball へのパスで指定されていた場合でも、設定された Galaxy サーバーからコレクションが再ダウンロードされます。

en: Collections can be specified as one or multiple collections or with a ``requirements.yml`` file just like ``ansible-galaxy collection install``.
ja: コレクションは、1 つまたは複数のコレクションとして、または ``ansible-galaxy collection install`` のように ``requirements.yml`` ファイルで指定できます。

en: To download a single collection and its dependencies:
ja: 1 つのコレクションとその依存関係をダウンロードするには、以下を行います。

en: To download a single collection at a specific version:
ja: 特定のバージョンで単一のコレクションをダウンロードするには、以下を実行します。

en: To download multiple collections either specify multiple collections as command line arguments as shown above or use a requirements file in the format documented with :ref:`collection_requirements_file`.
ja: 複数のコレクションをダウンロードするには、上記のように複数のコレクションをコマンドライン引数として指定するか、:ref:`collection_requirements_file` に記載されている形式で要件ファイルを使用します。

en: You can also download a source collection directory. The collection is built with the mandatory ``galaxy.yml`` file.
ja: ソースコレクションディレクトリーをダウンロードすることもできます。コレクションは必須の ``galaxy.yml`` ファイルでビルドされます。

en: You can download multiple source collections from a single namespace by providing the path to the namespace.
ja: 名前空間へのパスを指定すると、単一の名前空間から複数のソースコレクションをダウンロードできます。

en: All the collections are downloaded by default to the ``./collections`` folder but you can use ``-p`` or ``--download-path`` to specify another path:
ja: コレクションはすべて、デフォルトで ``./collections`` ディレクトリーにダウンロードされますが、``-p`` または ``--download-path`` を使用して別のパスを指定することもできます。

en: Once you have downloaded the collections, the folder contains the collections specified, their dependencies, and a ``requirements.yml`` file. You can use this folder as is with ``ansible-galaxy collection install`` to install the collections on a host without access to a Galaxy or Automation Hub server.
ja: コレクションをダウンロードした後、ディレクトリーには指定されたコレクション、その依存関係、および ``requirements.yml`` ファイルが含まれます。このディレクトリーは、``ansible-galaxy collection install`` と同じように、Galaxy サーバーまたは Automation Hub サーバーにアクセスせずにホストにコレクションをインストールできます。

en: Listing collections
ja: コレクション一覧の表示

en: To list installed collections, run ``ansible-galaxy collection list``. This shows all of the installed collections found in the configured collections search paths. It will also show collections under development which contain a galaxy.yml file instead of a MANIFEST.json. The path where the collections are located are displayed as well as version information. If no version information is available, a ``*`` is displayed for the version number.
ja: インストールされたコレクションを一覧表示するには、``ansible-galaxy collection list`` を実行します。これは、設定されたコレクションの検索パスにあるインストールされたコレクションをすべて表示します。これは、MANIFEST.json ではなく galaxy.yml ファイルが含まれる開発中のコレクションも表示します。コレクションが配置されているパスとバージョン情報が表示されます。バージョン情報がない場合は、``*`` がバージョン番号に表示されます。

en: Run with ``-vvv`` to display more detailed information.
ja: 詳細情報を表示するには、``-vvv`` を付けて実行します。

en: To list a specific collection, pass a valid fully qualified collection name (FQCN) to the command ``ansible-galaxy collection list``. All instances of the collection will be listed.
ja: 特定のコレクションを一覧表示するには、有効な完全修飾コレクション名 (FQCN) を ``ansible-galaxy collection list`` コマンドに渡します。コレクションのインスタンス一覧が表示されます。

en: To search other paths for collections, use the ``-p`` option. Specify multiple search paths by separating them with a ``:``. The list of paths specified on the command line will be added to the beginning of the configured collections search paths.
ja: 他のパスのコレクションを検索するには、``-p`` オプションを使用します。複数の検索パスを指定する場合は、``:`` で区切って指定します。コマンドラインで指定されたパスのリストは、設定されたコレクションの検索パスの先頭に追加されます。

en: Verifying collections
ja: コレクションの検証

en: Verifying collections with ``ansible-galaxy``
ja: ``ansible-galaxy`` でコレクションを検証

en: Once installed, you can verify that the content of the installed collection matches the content of the collection on the server. This feature expects that the collection is installed in one of the configured collection paths and that the collection exists on one of the configured galaxy servers.
ja: インストールすると、インストールしたコレクションの内容が、サーバー上のコレクションの内容と一致することを確認できます。この機能は、設定されたコレクションパスのいずれかにコレクションがインストールされ、設定された galaxy サーバーのいずれかにコレクションが存在することを想定します。

en: The output of the ``ansible-galaxy collection verify`` command is quiet if it is successful. If a collection has been modified, the altered files are listed under the collection name.
ja: ``ansible-galaxy collection verify`` コマンドの出力は、成功すると何も表示されません。コレクションを変更すると、変更したファイルがコレクション名の下に表示されます。

en: You can use the ``-vvv`` flag to display additional information, such as the version and path of the installed collection, the URL of the remote collection used for validation, and successful verification output.
ja: ``-vvv`` フラグを使用すると、インストールされたコレクションのバージョンとパス、検証に使用されるリモートコレクションの URL、正常な確認出力などの追加情報を表示できます。

en: If you have a pre-release or non-latest version of a collection installed you should include the specific version to verify. If the version is omitted, the installed collection is verified against the latest version available on the server.
ja: プレリリースまたは最新でないバージョンのコレクションをインストールしている場合は、検証する特定のバージョンを含める必要があります。バージョンが省略された場合、インストールされたコレクションは、サーバーで利用可能な最新バージョンと比較して検証されます。

en: In addition to the ``namespace.collection_name:version`` format, you can provide the collections to verify in a ``requirements.yml`` file. Dependencies listed in ``requirements.yml`` are not included in the verify process and should be verified separately.
ja: ``namespace.collection_name:version`` 形式に加えて、``requirements.yml`` ファイルで検証するコレクションを提供することができます。``requirements.yml`` に記載されている依存関係は、検証プロセスに含まれないため、別途検証する必要があります。

en: Verifying against ``tar.gz`` files is not supported. If your ``requirements.yml`` contains paths to tar files or URLs for installation, you can use the ``--ignore-errors`` flag to ensure that all collections using the ``namespace.name`` format in the file are processed.
ja: ``tar.gz`` ファイルに対する検証はサポートされていません。``requirements.yml`` にインストール用の tar ファイルや URL へのパスが含まれている場合は、``--ignore-errors`` フラグを使用して、ファイル内で ``namespace.name`` 形式を使用しているすべてのコレクションが処理されるようにすることができます。

en: Using collections in a Playbook
ja: Playbook でのコレクションの使用

en: Once installed, you can reference a collection content by its fully qualified collection name (FQCN):
ja: インストールが完了すると、完全修飾コレクション名 (FQCN) でコレクションコンテンツを参照できます。

en: This works for roles or any type of plugin distributed within the collection:
ja: これは、コレクションで配布されるロールまたはすべてのタイプのプラグインで機能します。

en: Simplifying module names with the ``collections`` keyword
ja: ``collections`` キーワードを使用したモジュール名の簡素化

en: The ``collections`` keyword lets you define a list of collections that your role or playbook should search for unqualified module and action names. So you can use the ``collections`` keyword, then simply refer to modules and action plugins by their short-form names throughout that role or playbook.
ja: ``collections`` キーワードを使用すると、ロールまたは Playbook が非修飾モジュールおよびアクション名を検索する必要のあるコレクションの一覧を定義できます。つまり、``collections`` キーワードを使用すると、そのロールまたは Playbook 全体で、モジュールおよびアクションプラグインを短縮名で参照できます。

en: If your playbook uses both the ``collections`` keyword and one or more roles, the roles do not inherit the collections set by the playbook. This is one of the reasons we recommend you always use FQCN. See below for roles details.
ja: Playbook で ``collections`` キーワードと 1 つ以上のロールの両方を使用している場合、ロールは Playbook で設定されたコレクションを継承しません。これが、常に FQCN を使用することが推奨される理由の 1 つです。ロールの詳細については、以下を参照してください。

en: Using ``collections`` in roles
ja: ロールでの ``collections`` の使用

en: Within a role, you can control which collections Ansible searches for the tasks inside the role using the ``collections`` keyword in the role's ``meta/main.yml``. Ansible will use the collections list defined inside the role even if the playbook that calls the role defines different collections in a separate ``collections`` keyword entry. Roles defined inside a collection always implicitly search their own collection first, so you don't need to use the ``collections`` keyword to access modules, actions, or other roles contained in the same collection.
ja: ロール内で、Ansible がロールの ``meta/main.yml`` の ``collections`` キーワードを使用して、ロール内のタスクを検索するコレクションを制御できます。Ansible は、ロールを呼び出す Playbook が別の ``collections`` キーワードエントリーで異なるコレクションを定義する場合でも、ロール内に定義されたコレクションリストを使用します。コレクション内で定義されたロールは、常に暗黙的に自身のコレクションを最初に検索するため、同じコレクションに含まれるモジュール、アクション、または他のロールにアクセスするために ``collections`` キーワードを使用する必要はありません。

en: Using ``collections`` in playbooks
ja: Playbook での ``collections`` の使用

en: In a playbook, you can control the collections Ansible searches for modules and action plugins to execute. However, any roles you call in your playbook define their own collections search order; they do not inherit the calling playbook's settings. This is true even if the role does not define its own ``collections`` keyword.
ja: Playbook では、Ansible が実行するモジュールやアクションプラグインを検索するコレクションを制御することができます。ただし、Playbook で呼び出したロールは、独自のコレクション検索順序を定義し、呼び出した Playbook の設定を継承しません。これは、ロールが独自の ``collections`` キーワードを定義していない場合でも同様です。

en: The ``collections`` keyword merely creates an ordered 'search path' for non-namespaced plugin and role references. It does not install content or otherwise change Ansible's behavior around the loading of plugins or roles. Note that an FQCN is still required for non-action or module plugins (for example, lookups, filters, tests).
ja: ``collections`` キーワードは、名前空間以外のプラグインおよびロール参照に対して、順序付けされた「検索パス」を作成します。コンテンツのインストールや、プラグインやロールの読み込みに関する Ansible の動作は変更されません。非アクションやモジュールプラグイン (検索、フィルター、テストなど) が必要なことに注意してください。

en: Using a playbook from a collection
ja: コレクションからの Playbook の使用

en: You can also distribute playbooks in your collection and invoke them using the same semantics you use for plugins:
ja: コレクションに Playbook を分散し、プラグインに使用するのと同じセマンティクスを使用して Playbook を呼び出すこともできます。

en: From inside a playbook:
ja: Playbook 内から、以下を実行します。

en: A few recommendations when creating such playbooks, ``hosts:`` should be generic or at least have a variable input.
ja: このような Playbook を作成する際のいくつかの推奨事項として、``hosts:`` は一般的なものにするか、少なくとも変数入力にする必要があります。

en: This will have an implied entry in the ``collections:`` keyword of ``my_namespace.my_collection`` just as with roles.
ja: これは、ロールと同様に、``my_namespace.my_collection`` の ``collections:`` キーワードに暗黙的なエントリーを持ちます。

en: Develop or modify a collection.
ja: コレクションを開発するか、または変更します。

en: Understand the collections metadata structure.
ja: コレクションのメタデータ構造を理解します。

en: The development mailing list
ja: 開発メーリングリスト

en: Working with command line tools
ja: コマンドラインツールの使用

en: Most users are familiar with `ansible` and `ansible-playbook`, but those are not the only utilities Ansible provides. Below is a complete list of Ansible utilities. Each page contains a description of the utility and a listing of supported parameters.
ja: ほとんどのユーザーは、`ansible` および `ansible-playbook` に精通しているものの、Ansible が提供する唯一のユーティリティーではありません。以下は、Ansible ユーティリティーの完全なリストです。各ページには、ユーティリティーの説明と、サポートされるパラメーター一覧が含まれています。

en: Data manipulation
ja: データ操作

en: In many cases, you need to do some complex operation with your variables, while Ansible is not recommended as a data processing/manipulation tool, you can use the existing Jinja2 templating in conjunction with the many added Ansible filters, lookups and tests to do some very complex transformations.
ja: 多くの場合は、変数を使用して複雑な操作を行う必要がありますが、Ansible はデータ処理/操作ツールとしてはお勧めできませんが、既存の Jinja2 テンプレートと、追加された多くの Ansible フィルター、ルックアップ、テストを併用することで、非常に複雑な変換を行うことができます。

en: Let's start with a quick definition of each type of plugin:
ja: まずは、それぞれのプラグインの定義を簡単に説明します。

en: lookups: Mainly used to query 'external data', in Ansible these were the primary part of loops using the ``with_<lookup>`` construct, but they can be used independently to return data for processing. They normally return a list due to their primary function in loops as mentioned previously. Used with the ``lookup`` or ``query`` Jinja2 operators.
ja: lookups: 主に「外部データ」を照会するために使用されます。Ansible では、``with_<lookup>`` 構成を使用したループの主要部分でしたが、処理するデータを返すために独立して使用することもできます。前述のようにループでの主な機能であるため、通常はリストを返します。Jinja2 の演算子 ``lookup`` または ``query`` と一緒に使用します。

en: filters: used to change/transform data, used with the ``|`` Jinja2 operator.
ja: filters: Jinja2 演算子 ``|`` で使用される、データの変更/変換に使用します。

en: tests: used to validate data, used with the ``is`` Jinja2 operator.
ja: tests: Jinja2 演算子 ``is`` で使用されるデータの検証に使用されます。

en: Loops and list comprehensions
ja: ループおよびリストの競合

en: Most programming languages have loops (``for``, ``while``, and so on) and list comprehensions to do transformations on lists including lists of objects. Jinja2 has a few filters that provide this functionality: ``map``, ``select``, ``reject``, ``selectattr``, ``rejectattr``.
ja: ほとんどのプログラミング言語にはループ (``for``、``while`` など) やリスト内包があり、オブジェクトのリストを含むリストの変換を行うことができます。Jinja2 には、このような機能を提供するフィルターがいくつかあります (``map``、``select``、``reject``、``selectattr``、``rejectattr``)。

en: map: this is a basic for loop that just allows you to change every item in a list, using the 'attribute' keyword you can do the transformation based on attributes of the list elements.
ja: map: これは基本的な for ループで、リストのすべての項目を変更することができます。「attribute」キーワードを使用すると、リスト要素の属性に基づいて変換を行うことができます。

en: select/reject: this is a for loop with a condition, that allows you to create a subset of a list that matches (or not) based on the result of the condition.
ja: select/reject: これは、条件のあるループ用であり、条件の結果に基づいて一致する (または一致しない) リストのサブセットを作成できます。

en: selectattr/rejectattr: very similar to the above but it uses a specific attribute of the list elements for the conditional statement.
ja: selectattr/rejectattr: 上記と非常に似ていますが、条件文に対して list 要素の特定の属性を使用します。

en: Use a loop to create exponential backoff for retries/until.
ja: ループを使用して再試行/一時停止の指数関数的なバックオフを作成します。

en: Extract keys from a dictionary matching elements from a list
ja: リストから一致するディクショナリー要素からキーを抽出します。

en: The Python equivalent code would be:
ja: Python と同等のコードは以下のとおりです。

en: There are several ways to do it in Ansible, this is just one example:
ja: Ansible で実行する方法はいくつかあります。以下は一例です。

en: Way to extract matching keys from a list of dictionaries
ja: ディクショナリーのリストから一致するキーを抽出する方法

en: Results of debug task, a list with the extracted keys
ja: デバッグタスクの結果 (展開した鍵を含むリスト)

en: Get the unique list of values of a variable that vary per host
ja: ホストごとに異なる変数の値の一意のリストを取得します。

en: Find mount point
ja: マウントポイントの検索

en: In this case, we want to find the mount point for a given path across our machines, since we already collect mount facts, we can use the following:
ja: 今回のケースでは、マシン間で指定されたパスのマウントポイントを検索したいのですが、すでにマウントファクトを収集しているため、次のように使用できます。

en: Use selectattr to filter mounts into list I can then sort and select the last from
ja: selectattr を使用してマウントにフィルターを設定してリストにし、ソートして最後のものを選択します。

en: Omit elements from a list
ja: リストからの要素を省略

en: The special ``omit`` variable ONLY works with module options, but we can still use it in other ways as an identifier to tailor a list of elements:
ja: 特別な ``omit`` 変数は、モジュールオプションでのみ機能しますが、要素のリストを調整するための識別子として、他の方法でも使用することができます。

en: Inline list filtering when feeding a module option
ja: モジュールオプションのフィード時のインラインリストのフィルタリング

en: Another way is to avoid adding elements to the list in the first place, so you can just use it directly:
ja: もう 1 つの方法は、そもそもリストに要素を追加しないようにして、直接利用することです。

en: Using set_fact in a loop to increment a list conditionally
ja: ループで set_fact を使用してリストを条件付きで増分する

en: Combine values from same list of dicts
ja: 同じリストのディクショナリーの値を結合する

en: Combining positive and negative filters from examples above, you can get a 'value when it exists' and a 'fallback' when it doesn't.
ja: 上記の例から正のフィルターと負のフィルターを組み合わせると、「存在する場合の値」と存在しない場合の「フォールバック」を得ることができます。

en: Use selectattr and rejectattr to get the ansible_host or inventory_hostname as needed
ja: 必要に応じて、selectattr および rejectattr を使用して ansible_host または inventory_hostname を取得します。

en: Custom Fileglob Based on a Variable
ja: 変数に基づくカスタムファイルグロブ

en: This example uses `Python argument list unpacking <https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists>`_ to create a custom list of fileglobs based on a variable.
ja: この例では、`Python argument list unpacking <https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists>`_ を使用して、変数に基づいてファイルグロブのカスタムリストを作成します。

en: Using fileglob with a list based on a variable.
ja: 変数に基づくリストでファイルグロブの使用。

en: Complex Type transformations
ja: 複雑なタイプ変換

en: Jinja provides filters for simple data type transformations (``int``, ``bool``, and so on), but when you want to transform data structures things are not as easy. You can use loops and list comprehensions as shown above to help, also other filters and lookups can be chained and leveraged to achieve more complex transformations.
ja: Jinja には単純なデータ型変換のためのフィルターが用意されていますが (``int``、``bool`` など)、データ構造を変換したい場合はそう簡単ではありません。上記のようにループやリスト内包を利用することもできますし、他のフィルターやルックアップを連鎖させて利用することで、より複雑な変換を行うことができます。

en: Create dictionary from list
ja: リストからディクショナリーを作成

en: In most languages it is easy to create a dictionary (a.k.a. map/associative array/hash and so on) from a list of pairs, in Ansible there are a couple of ways to do it and the best one for you might depend on the source of your data.
ja: ほとんどの言語では、ペアのリストからディクショナリー (マップ、連想配列、ハッシュなど) を簡単に作成できますが、Ansible ではいくつかの方法があり、データのソースによって最適な方法が異なります。

en: These example produces ``{"a": "b", "c": "d"}``
ja: これらの例では、``{"a": "b", "c": "d"}`` を生成します。

en: Simple list to dict by assuming the list is [key, value , key, value, ...]
ja: リストが [key, value , key, value, ...] であることを前提とする、ディクショナリーへの単純なリスト

en: It is simpler when we have a list of pairs:
ja: ペアのリストがある場合はより簡単にできます。

en: Both end up being the same thing, with ``slice(2)`` transforming ``single_list`` to a ``list_of_pairs`` generator.
ja: ``slice(2)`` が ``single_list`` を ``list_of_pairs`` ジェネレーターに変換することで、両方とも同じ内容になります。

en: A bit more complex, using ``set_fact`` and a ``loop`` to create/update a dictionary with key value pairs from 2 lists:
ja: ``set_fact`` と ``loop`` を使用して、2 つのリストからキーと値のペアを持つ、もう少し複雑なディクショナリーを作成/更新します。

en: Using set_fact to create a dictionary from a set of lists
ja: set_fact を使用してリストのセットからのディクショナリーの作成

en: This results in ``{"foo": "a", "var": "b", "bar": "c"}``.
ja: その結果、``{"foo": "a", "var": "b", "bar": "c"}`` になります。

en: You can even combine these simple examples with other filters and lookups to create a dictionary dynamically by matching patterns to variable names:
ja: これらの簡単な例を他のフィルターや検索と組み合わせて、変数名にパターンを一致させて動的にディクショナリーを作成することもできます。

en: Using 'vars' to define dictionary from a set of lists without needing a task
ja: 「vars」を使用して、タスクを必要とせずにリストのセットからディクショナリーを定義

en: A quick explanation, since there is a lot to unpack from these two lines:
ja: 以下の 2 つの行から展開するため、簡単な説明があります。

en: The ``varnames`` lookup returns a list of variables that match "begin with ``my``".
ja: ``varnames`` 検索は、「begin with ``my``」に一致する変数の一覧を返します。

en: Then feeding the list from the previous step into the ``vars`` lookup to get the list of values. The ``*`` is used to 'dereference the list' (a pythonism that works in Jinja), otherwise it would take the list as a single argument.
ja: そして、前のステップのリストを ``vars`` 検索に送り、値のリストを取得します。``*`` は「リストを参照解除する」ために使用されます (Jinja でも通用する python の手法です)。そうでなければ、リストを 1 つの引数として受け取ることになります。

en: Both lists get passed to the ``zip`` filter to pair them off into a unified list (key, value, key2, value2, ...).
ja: 両方のリストは、``zip`` フィルターに渡され、それらをペアにして統一されたリスト (key, value, key2, value2, ...) にします。

en: The dict function then takes this 'list of pairs' to create the dictionary.
ja: その後、dict 関数はこの「ペアのリスト」を取得し、ディクショナリーを作成します。

en: An example on how to use facts to find a host's data that meets condition X:
ja: ファクトを使用して、条件 X を満たすホストのデータを検索する例:

en: Using an example from @zoradache on reddit, to show the 'uptime in days/hours/minutes' (assumes facts where gathered). https://www.reddit.com/r/ansible/comments/gj5a93/trying_to_get_uptime_from_seconds/fqj2qr3/
ja: reddit の @zoradache 氏の例を参考に、「日/時間/分単位での稼働時間」を表示しています (ファクトが収集されていることを前提としています) (https://www.reddit.com/r/ansible/comments/gj5a93/trying_to_get_uptime_from_seconds/fqj2qr3/)。

en: Jinja2 filters included with Ansible
ja: Ansible に含まれる Jinja2 フィルター

en: Jinja2 tests included with Ansible
ja: Ansible に含まれる Jinja2 テスト

en: Jinja2 documentation, includes lists for core filters and tests
ja: Jinja2 ドキュメント。コアフィルターおよびテストの一覧が含まれます。

en: Connection methods and details
ja: 接続方法および詳細

en: This section shows you how to expand and refine the connection methods Ansible uses for your inventory.
ja: 本セクションでは、Ansible がインベントリーに使用する接続方法を拡張および改良する方法を示します。

en: ControlPersist and paramiko
ja: ControlPersist および paramiko

en: By default, Ansible uses native OpenSSH, because it supports ControlPersist (a performance feature), Kerberos, and options in ``~/.ssh/config`` such as Jump Host setup. If your control machine uses an older version of OpenSSH that does not support ControlPersist, Ansible will fallback to a Python implementation of OpenSSH called 'paramiko'.
ja: デフォルトでは、Ansible はネイティブの OpenSSH を使用します。これは、ControlPersist (パフォーマンス機能)、Kerberos、および Jump Host 設定などの ``~/.ssh/config`` のオプションをサポートしているためです。コントロールマシンが ControlPersist をサポートしていない古いバージョンの OpenSSH を使用している場合、Ansible は「paramiko」と呼ばれる Python による OpenSSH の実装にフォールバックします。

en: Setting a remote user
ja: リモートユーザーの設定

en: By default, Ansible connects to all remote devices with the user name you are using on the control node. If that user name does not exist on a remote device, you can set a different user name for the connection. If you just need to do some tasks as a different user, look at :ref:`become`. You can set the connection user in a playbook:
ja: デフォルトでは、Ansible はすべてのリモートデバイスに、コントロールノードで使用しているユーザー名で接続します。リモートデバイスにそのユーザー名が存在しない場合は、接続に別のユーザー名を設定することができます。別のユーザーとしていくつかのタスクを実行するだけの場合は、「:ref:`become`」を参照してください。Playbookで接続ユーザーを設定することができます。

en: as a host variable in inventory:
ja: インベントリーのホスト変数では、以下のようになります。

en: or as a group variable in inventory:
ja: また、インベントリーのグローバル変数では、以下のようになります。

en: Setting up SSH keys
ja: SSH キーの設定

en: By default, Ansible assumes you are using SSH keys to connect to remote machines.  SSH keys are encouraged, but you can use password authentication if needed with the ``--ask-pass`` option. If you need to provide a password for :ref:`privilege escalation <become>` (sudo, pbrun, and so on), use ``--ask-become-pass``.
ja: デフォルトでは、Ansible は SSH 鍵を使用してリモートマシンに接続することを想定しています。SSH キーが推奨されますが、必要に応じて ``--ask-pass`` オプションを使用してパスワード認証を使用できます。:ref:`privilege escalation <become>` (sudo、pbrun など) のパスワードを提供する必要がある場合は、``--ask-become-pass`` を使用します。

en: Ansible does not expose a channel to allow communication between the user and the ssh process to accept a password manually to decrypt an ssh key when using the ssh connection plugin (which is the default). The use of ``ssh-agent`` is highly recommended.
ja: Ansible は、ssh 接続プラグインを使用している場合 (これがデフォルトです)は、ユーザーと ssh プロセスの間の通信を可能にするチャンネルを公開しておらず、ssh 鍵を復号するためのパスワードを手動で受け入れることができません。``ssh-agent`` を使用することが強く推奨されます。

en: To set up SSH agent to avoid retyping passwords, you can do:
ja: パスワードを再入力しないように SSH エージェントをセットアップするには、次のようにします。

en: Depending on your setup, you may wish to use Ansible's ``--private-key`` command line option to specify a pem file instead.  You can also add the private key file:
ja: セットアップによっては、代わりに Ansible の ``--private-key`` コマンドラインオプションを使用して pem ファイルを指定することもできます。秘密鍵ファイルを追加することもできます。

en: Another way to add private key files without using ssh-agent is using ``ansible_ssh_private_key_file`` in an inventory file as explained here:  :ref:`intro_inventory`.
ja: ssh-agent を使用せずに秘密鍵ファイルを追加する別の方法は、:ref:`intro_inventory` で説明するように、インベントリーファイルで ``ansible_ssh_private_key_file`` を使用することです。

en: Running against localhost
ja: ローカルホストに対して実行

en: You can run commands against the control node by using "localhost" or "127.0.0.1" for the server name:
ja: サーバー名に「localhost」または「127.0.0.1」を使用して、コントロールノードにコマンドを実行できます。

en: You can specify localhost explicitly by adding this to your inventory file:
ja: これをインベントリーファイルに追加して、localhost を明示的に指定できます。

en: Managing host key checking
ja: ホスト鍵の確認の管理

en: Ansible enables host key checking by default. Checking host keys guards against server spoofing and man-in-the-middle attacks, but it does require some maintenance.
ja: Ansible は、デフォルトでホスト鍵の確認を有効にします。ホスト鍵を確認すると、サーバーのなりすましや中間者攻撃から保護されますが、メンテナンスが必要です。

en: If a host is reinstalled and has a different key in 'known_hosts', this will result in an error message until corrected.  If a new host is not in 'known_hosts' your control node may prompt for confirmation of the key, which results in an interactive experience if using Ansible, from say, cron. You might not want this.
ja: ホストが再インストールされ、「known_hosts」に異なるキーがある場合は、修正されるまでエラーメッセージが表示されます。新しいホストが「known_hosts」にない場合、コントロールノードはキーの確認を求めるかもしれませんが、これは Ansible を cron などから使用している場合は、インタラクティブな操作になります。このように動作しないようにしたい場合があります。

en: If you understand the implications and wish to disable this behavior, you can do so by editing ``/usr/local/etc/ansible/ansible.cfg`` or ``~/.ansible.cfg``:
ja: この動作を無効にした場合の影響を理解し、無効にする場合は、``/usr/local/etc/ansible/ansible.cfg`` または ``~/.ansible.cfg`` 編集します。

en: Alternatively this can be set by the :envvar:`ANSIBLE_HOST_KEY_CHECKING` environment variable:
ja: また、これは、:envvar:`ANSIBLE_HOST_KEY_CHECKING` 環境変数により設定できます。

en: Also note that host key checking in paramiko mode is reasonably slow, therefore switching to 'ssh' is also recommended when using this feature.
ja: また、paramiko モードでのホストキーチェックはかなり遅いため、この機能を使用する場合は「ssh」に切り替えることも推奨されます。

en: Other connection methods
ja: その他の接続方法

en: Ansible can use a variety of connection methods beyond SSH. You can select any connection plugin, including managing things locally and managing chroot, lxc, and jail containers. A mode called 'ansible-pull' can also invert the system and have systems 'phone home' via scheduled git checkouts to pull configuration directives from a central repository.
ja: Ansible では、SSH 以外にもさまざまな接続方法を利用することができます。ローカルでの管理、chroot コンテナー、lxc コンテナー、および jail コンテナーの管理など、任意の接続プラグインを選択できます。「ansible-pull」と呼ばれるモードでは、システムを反転させて、スケジュールされた git チェックアウトを介してシステムを「phone home」させ、中央のリポジトリーから設定ディレクティブを引き出すこともできます。

en: Playbook Example: Continuous Delivery and Rolling Upgrades
ja: Playbook の例: 継続的デリバリーおよびローリングアップグレード

en: What is continuous delivery?
ja: 継続的デリバリーとは

en: Continuous delivery (CD) means frequently delivering updates to your software application.
ja: 継続的デリバリー (CD) は、ソフトウェアアプリケーションに更新を頻繁に配信することを意味します。

en: The idea is that by updating more often, you do not have to wait for a specific timed period, and your organization gets better at the process of responding to change.
ja: 更新の頻度を上げることで、特定の期間を待つ必要がなくなり、組織は変化に対応するプロセスを改善できるという考え方です。

en: Some Ansible users are deploying updates to their end users on an hourly or even more frequent basis -- sometimes every time there is an approved code change.  To achieve this, you need tools to be able to quickly apply those updates in a zero-downtime way.
ja: Ansible のユーザーの中には、エンドユーザーにアップデートを毎時またはそれ以上の頻度で配布している人がいます。承認されたコード変更があるたびに配布している場合もあります。そのためには、ダウンタイムなしで更新を迅速に適用できるツールが必要です。

en: This document describes in detail how to achieve this goal, using one of Ansible's most complete example playbooks as a template: lamp_haproxy. This example uses a lot of Ansible features: roles, templates, and group variables, and it also comes with an orchestration playbook that can do zero-downtime rolling upgrades of the web application stack.
ja: 本ガイドでは、Ansible の最も完成度の高いサンプル Playbook の 1 つである lamp_haproxy をテンプレートとして、この目標を達成する方法を詳細に説明します。この例では、ロール、テンプレート、グループ変数などの Ansible の機能が数多く使用されており、Web アプリケーションスタックのローリングアップグレードをダウンタイムなしで行うことができるオーケストレーション Playbook も付属しています。

en: The playbooks deploy Apache, PHP, MySQL, Nagios, and HAProxy to a CentOS-based set of servers.
ja: Playbook は Apache、PHP、MySQL、Nagios、および HAProxy を CentOS ベースのサーバーセットにデプロイします。

en: We're not going to cover how to run these playbooks here. Read the included README in the github project along with the example for that information. Instead, we're going to take a close look at every part of the playbook and describe what it does.
ja: ここでは、これらの Playbook を実行する方法については説明しません。その情報については、github プロジェクトに含まれる README をサンプルと一緒に読んでください。その代わり、Playbook の各部分をよく見て、それが何をするのかを説明します。

en: Site deployment
ja: サイトのデプロイメント

en: Let's start with ``site.yml``. This is our site-wide deployment playbook. It can be used to initially deploy the site, as well as push updates to all of the servers:
ja: まず、``site.yml`` から始めましょう。これは、サイト全体のデプロイメント Playbook です。この Playbook を使用して、サイトの初期デプロイメントと、すべてのサーバーへの更新のプッシュを行うことができます。

en: If you're not familiar with terms like playbooks and plays, you should review :ref:`working_with_playbooks`.
ja: Playbook やプレイなどの用語に慣れていない場合は、:ref:`working_with_playbooks` を確認してください。

en: In this playbook we have 5 plays. The first one targets ``all`` hosts and applies the ``common`` role to all of the hosts. This is for site-wide things like yum repository configuration, firewall configuration, and anything else that needs to apply to all of the servers.
ja: この Playbook では 5 つのプレイを紹介します。最初の Playbook は ``all`` のホストを対象とし、``common`` のロールをすべてのホストに適用します。これは、yum リポジトリーの設定やファイアウォールの設定など、サイト全体ですべてのサーバーに適用する必要があるものを対象としています。

en: The next four plays run against specific host groups and apply specific roles to those servers. Along with the roles for Nagios monitoring, the database, and the web application, we've implemented a ``base-apache`` role that installs and configures a basic Apache setup. This is used by both the sample web application and the Nagios hosts.
ja: 次の 4 つのプレイは、特定のホストグループに対して実行し、それらのサーバーに特定のロールを適用します。Nagios 監視、データベース、Web アプリケーションのロールと一緒に、基本的な Apache セットアップをインストールして設定する ``base-apache`` ロールを実装しました。これは、サンプルの Web アプリケーションと Nagios ホストの両方で使用されます。

en: Reusable content: roles
ja: 再利用可能なコンテンツ: ロール

en: By now you should have a bit of understanding about roles and how they work in Ansible. Roles are a way to organize content: tasks, handlers, templates, and files, into reusable components.
ja: その結果、ロールおよび Ansible での動作についてある程度理解できるはずです。ロールは、タスク、ハンドラー、テンプレート、ファイルなどのコンテンツを再利用可能なコンポーネントに整理する方法です。

en: This example has six roles: ``common``, ``base-apache``, ``db``, ``haproxy``, ``nagios``, and ``web``. How you organize your roles is up to you and your application, but most sites will have one or more common roles that are applied to all systems, and then a series of application-specific roles that install and configure particular parts of the site.
ja: この例では、``common``、``base-apache``、``db``、``haproxy``、``nagios``、および ``web`` の 6 つのロールがあります。ロールをどのように編成するかは、ニーズおよび使用するアプリケーション次第ですが、ほとんどのサイトでは、すべてのシステムに適用される 1 つまたは複数の共通ロールと、サイトの特定の部分をインストールおよび設定する一連のアプリケーション固有のロールがあります。

en: Roles can have variables and dependencies, and you can pass in parameters to roles to modify their behavior. You can read more about roles in the :ref:`playbooks_reuse_roles` section.
ja: ロールは変数と依存関係を持つことができ、パラメーターをロールに渡すことでその動作を変更できます。ロールについては、「:ref:`playbooks_reuse_roles`」セクションで詳しく説明しています。

en: Configuration: group variables
ja: 設定: グループ変数

en: Group variables are variables that are applied to groups of servers. They can be used in templates and in playbooks to customize behavior and to provide easily-changed settings and parameters. They are stored in a directory called ``group_vars`` in the same location as your inventory. Here is lamp_haproxy's ``group_vars/all`` file. As you might expect, these variables are applied to all of the machines in your inventory:
ja: グループ変数は、サーバーのグループに適用される変数です。テンプレートや Playbook で使用することで、動作をカスタマイズしたり、簡単に変更できる設定やパラメーターを提供することができます。グループ変数は、インベントリーと同じ場所にある ``group_vars`` ディレクトリーに保存されます。以下は lamp_haproxy の``group_vars/all`` ファイルです。ご想像のとおり、これらの変数はインベントリー内のすべてのマシンに適用されます。

en: This is a YAML file, and you can create lists and dictionaries for more complex variable structures. In this case, we are just setting two variables, one for the port for the web server, and one for the NTP server that our machines should use for time synchronization.
ja: これは YAML ファイルですが、リストやディクショナリーを作成することで、より複雑な変数構造にすることができます。ここでは 2 つの変数を設定しています。1 つは Web サーバーのポート用、もう 1 つはマシンが時刻同期に使用する NTP サーバーのポート用です。

en: Here's another group variables file. This is ``group_vars/dbservers`` which applies to the hosts in the ``dbservers`` group:
ja: 次は、別のグループ変数ファイルです。これは、``dbservers`` グループのホストに適用される ``group_vars/dbservers`` です。

en: If you look in the example, there are group variables for the ``webservers`` group and the ``lbservers`` group, similarly.
ja: 上記の例を参照すると、同様に ``webservers`` グループと ``lbservers`` グループのグループ変数も存在します。

en: These variables are used in a variety of places. You can use them in playbooks, like this, in ``roles/db/tasks/main.yml``:
ja: これらの変数はさまざまな場所で使用され、``roles/db/tasks/main.yml`` のように Playbook でも使用できます。

en: You can also use these variables in templates, like this, in ``roles/common/templates/ntp.conf.j2``:
ja: これらの変数は、``roles/common/templates/ntp.conf.j2`` で、テンプレートで使用することもできます。

en: You can see that the variable substitution syntax of {{ and }} is the same for both templates and variables. The syntax inside the curly braces is Jinja2, and you can do all sorts of operations and apply different filters to the data inside. In templates, you can also use for loops and if statements to handle more complex situations, like this, in ``roles/common/templates/iptables.j2``:
ja: {{ および }} の変数置換構文は、テンプレートでも変数でも同じであることがわかります。中括弧の中の構文は Jinja2 のもので、中のデータに対してあらゆる種類の操作やさまざまなフィルターを適用することができます。テンプレートでは、for ループや if 文を使用して、以下のように、``roles/common/templates/iptables.j2`` でより複雑な状況を処理することもできます。

en: This is testing to see if the inventory name of the machine we're currently operating on (``inventory_hostname``) exists in the inventory group ``dbservers``. If so, that machine will get an iptables ACCEPT line for port 3306.
ja: これは、現在操作しているマシンのインベントリー名 (``inventory_hostname``) が、インベントリーグループ ``dbservers`` に存在するかどうかをテストしています。存在する場合、そのマシンはポート 3306 に対して iptables の ACCEPT 行を取得します。

en: Here's another example, from the same template:
ja: 以下は、同じテンプレートの別の例です。

en: This loops over all of the hosts in the group called ``monitoring``, and adds an ACCEPT line for each monitoring hosts' default IPv4 address to the current machine's iptables configuration, so that Nagios can monitor those hosts.
ja: これは、``monitoring`` というグループのすべてのホストをループし、現在のマシンの iptables 設定に、各監視ホストのデフォルトの IPv4 アドレスに ACCEPT 行を追加し、Nagios がそれらのホストを監視できるようにします。

en: You can learn a lot more about Jinja2 and its capabilities `here <https://jinja.palletsprojects.com/>`_, and you can read more about Ansible variables in general in the :ref:`playbooks_variables` section.
ja: Jinja2 とその機能については `こちら <https://jinja.palletsprojects.com/>`_ で、また Ansible の変数全般については :ref:`playbooks_variables` で詳しく説明しています。

en: The rolling upgrade
ja: ローリングアップグレード

en: Now you have a fully-deployed site with web servers, a load balancer, and monitoring. How do you update it? This is where Ansible's orchestration features come into play. While some applications use the term 'orchestration' to mean basic ordering or command-blasting, Ansible refers to orchestration as 'conducting machines like an orchestra', and has a pretty sophisticated engine for it.
ja: これで、Web サーバー、ロードバランサー、および監視機能を備えた完全なサイトが展開されました。これをどうやって更新しますか。ここで、Ansible のオーケストレーション機能が活躍します。アプリケーションの中には、「オーケストレーション」という言葉を、基本的な命令やコマンドブラストの意味で使用しているものもありますが、Ansible ではオーケストレーションを「オーケストラのようにマシンを指揮すること」と呼んでおり、そのためにかなり高度なエンジンを備えています。

en: Ansible has the capability to do operations on multi-tier applications in a coordinated way, making it easy to orchestrate a sophisticated zero-downtime rolling upgrade of our web application. This is implemented in a separate playbook, called ``rolling_update.yml``.
ja: Ansible には、多層アプリケーションの操作を連携して行う機能があり、Web アプリケーションのダウンタイムなしのローリングアップグレードを簡単に編成 (オーケストレーション) することができます。これは、``rolling_update.yml`` という名前の別の Playbook に実装されています。

en: Looking at the playbook, you can see it is made up of two plays. The first play is very simple and looks like this:
ja: Playbook を確認すると、2 つのプレイで構成されていることがわかります。1 つ目のプレイはとてもシンプルで、次のようになります。

en: What's going on here, and why are there no tasks? You might know that Ansible gathers "facts" from the servers before operating upon them. These facts are useful for all sorts of things: networking information, OS/distribution versions, and so on. In our case, we need to know something about all of the monitoring servers in our environment before we perform the update, so this simple play forces a fact-gathering step on our monitoring servers. You will see this pattern sometimes, and it's a useful trick to know.
ja: どうなっているのでしょうか。なぜタスクが存在しないのでしょうか。Ansible は、サーバーを操作する前に、サーバーから「ファクト」を収集することをご存知かもしれません。これらのファクトは、ネットワーク情報、OS/ディストリビューションのバージョンなど、あらゆる種類のものに役立ちます。今回のケースでは、更新を実行する前に、環境内のすべての監視サーバーについて何かを知る必要があるため、この単純なプレイによって、監視サーバーのファクト収集ステップが強制的に実行されます。このパターンは時々見かけますが、知っておくと便利なワザです。

en: The next part is the update play. The first part looks like this:
ja: 次の部分は、更新プレイです。最初の部分は以下のようになっています。

en: This is just a normal play definition, operating on the ``webservers`` group. The ``serial`` keyword tells Ansible how many servers to operate on at once. If it's not specified, Ansible will parallelize these operations up to the default "forks" limit specified in the configuration file. But for a zero-downtime rolling upgrade, you may not want to operate on that many hosts at once. If you had just a handful of webservers, you may want to set ``serial`` to 1, for one host at a time. If you have 100, maybe you could set ``serial`` to 10, for ten at a time.
ja: これは通常のプレイ定義で、``webservers`` グループで動作します。``serial`` キーワードは、一度に操作するサーバーの数を Ansible に伝えます。このキーワードが指定されていない場合、Ansible は設定ファイルで指定されているデフォルトの「フォーク」制限まで、これらの操作を並列化します。しかし、ダウンタイムなしのローリングアップグレードでは、それほど多くのホストを一度に操作する必要はないでしょう。Web サーバーがほんの一握りしかない場合には、``serial`` を 1 に設定して、一度に 1 つのホストに対して行うのがよいでしょう。100 台ある場合は、``serial`` を 10 に設定して、一度に 10 台のホストを操作することもできます。

en: Here is the next part of the update play:
ja: 以下は更新プレイの次の部分です。

en: The ``serial`` keyword forces the play to be executed in 'batches'. Each batch counts as a full play with a subselection of hosts. This has some consequences on play behavior. For example, if all hosts in a batch fails, the play fails, which in turn fails the entire run. You should consider this when combining with ``max_fail_percentage``.
ja: ``serial`` キーワードを使用すると、プレイが「バッチ」で実行されます。各バッチは、ホストのサブセレクションを使用した完全なプレイとしてカウントされます。これは、プレイの動作にいくつかの影響を与えます。たとえば、バッチ内のすべてのホストが失敗した場合、そのプレイは失敗し、その結果、全体の実行も失敗します。``max_fail_percentage`` と組み合わせる場合は、この点を考慮する必要があります。

en: The ``pre_tasks`` keyword just lets you list tasks to run before the roles are called. This will make more sense in a minute. If you look at the names of these tasks, you can see that we are disabling Nagios alerts and then removing the webserver that we are currently updating from the HAProxy load balancing pool.
ja: ``pre_tasks`` キーワードでは、ロールが呼び出される前に実行するタスクをリストアップすることができます。これはすぐに意味をなします。これらのタスクの名前を見ると、Nagios のアラートを無効にして、現在更新中の Web サーバーを HAProxy 負荷分散プールから削除していることがわかります。

en: The ``delegate_to`` and ``loop`` arguments, used together, cause Ansible to loop over each monitoring server and load balancer, and perform that operation (delegate that operation) on the monitoring or load balancing server, "on behalf" of the webserver. In programming terms, the outer loop is the list of web servers, and the inner loop is the list of monitoring servers.
ja: ``delegate_to`` 引数および ``loop`` 引数を一緒に使用すると、Ansible が各監視サーバーとロードバランサーをループし、Web サーバーに「代わって」監視サーバーまたは負荷分散サーバーでその操作を実行 (操作を委譲) することになります。プログラミング用語では、外部ループは Web サーバーのリスト、内部ループは監視サーバーのリストになります。

en: Note that the HAProxy step looks a little complicated.  We're using HAProxy in this example because it's freely available, though if you have (for instance) an F5 or Netscaler in your infrastructure (or maybe you have an AWS Elastic IP setup?), you can use Ansible modules  to communicate with them instead.  You might also wish to use other monitoring modules instead of nagios, but this just shows the main goal of the 'pre tasks' section -- take the server out of monitoring, and take it out of rotation.
ja: HAProxy のステップは少し複雑に見えることに注意してください。この例では HAProxy を使用していますが、これは自由に利用できるからです。しかし、(たとえば) F5 や Netscaler がインフラストラクチャーにある場合 (あるいは AWS の Elastic IP を設定している場合) は、代わりに Ansible モジュールを使用してそれらと通信することができます。nagios の代わりに他の監視モジュールを使用することもできますが、これは「事前タスク」セクションの主な目的、つまり、サーバーを監視から外し、ローテーションから外すことを示しています。

en: The next step simply re-applies the proper roles to the web servers. This will cause any configuration management declarations in ``web`` and ``base-apache`` roles to be applied to the web servers, including an update of the web application code itself. We don't have to do it this way--we could instead just purely update the web application, but this is a good example of how roles can be used to reuse tasks:
ja: 次の手順では、適切なロールを Web サーバーに再適用するだけです。これにより、``web`` と ``base-apache`` のロールにおける構成管理宣言が Web サーバーに適用され、Web アプリケーションコード自体の更新も行われます。このようにしなくても、純粋に Web アプリケーションを更新するだけでもよいのですが、これはロールを使用してタスクを再利用する方法のよい例です。

en: Finally, in the ``post_tasks`` section, we reverse the changes to the Nagios configuration and put the web server back in the load balancing pool:
ja: 最後に、``post_tasks`` セクションで、Nuppet 設定への変更を元に戻し、Web サーバーを負荷分散プールに戻します。

en: Again, if you were using a Netscaler or F5 or Elastic Load Balancer, you would just substitute in the appropriate modules instead.
ja: NetScaler、F5、または Elastic Load Balancer を使用する場合は、代わりに適切なモジュールに置き換えてください。

en: Managing other load balancers
ja: その他のロードバランサーの管理

en: In this example, we use the simple HAProxy load balancer to front-end the web servers. It's easy to configure and easy to manage. As we have mentioned, Ansible has support for a variety of other load balancers like Citrix NetScaler, F5 BigIP, Amazon Elastic Load Balancers, and more. See the :ref:`working_with_modules` documentation for more information.
ja: この例では、シンプルな HAProxy ロードバランサーを Web サーバーのフロントエンドに使用しています。設定が簡単で、管理も容易です。これまで述べてきたように、Ansible は Citrix NetScaler、F5 BigIP、Amazon Elastic Load Balancer など、他のさまざまなロードバランサーをサポートしています。詳細は、「:ref:`working_with_modules`」のドキュメントをご覧ください。

en: For other load balancers, you may need to send shell commands to them (like we do for HAProxy above), or call an API, if your load balancer exposes one. For the load balancers for which Ansible has modules, you may want to run them as a ``local_action`` if they contact an API. You can read more about local actions in the :ref:`playbooks_delegation` section.  Should you develop anything interesting for some hardware where there is not a module, it might make for a good contribution!
ja: その他のロードバランサーの場合は、シェルコマンドを送信するか (上記の HAProxy の場合と同様)、ロードバランサーが API を公開している場合は API を呼び出す必要があるかもしれません。Ansible にモジュールが用意されているロードバランサーについては、API を呼び出す場合には、``local_action`` として実行することもできます。ローカルアクションについては、:ref:`playbooks_delegation` セクションで詳しく説明しています。モジュールがないハードウェアで何か面白いものを開発したら、良い貢献になるかもしれません。

en: Continuous delivery end-to-end
ja: 継続的デリバリーのエンドツーエンド

en: Now that you have an automated way to deploy updates to your application, how do you tie it all together? A lot of organizations use a continuous integration tool like `Jenkins <https://jenkins.io/>`_ or `Atlassian Bamboo <https://www.atlassian.com/software/bamboo>`_ to tie the development, test, release, and deploy steps together. You may also want to use a tool like `Gerrit <https://www.gerritcodereview.com/>`_ to add a code review step to commits to either the application code itself, or to your Ansible playbooks, or both.
ja: アプリケーションの更新を自動的にデプロイする方法が確立されましたが、これらをどのようにまとめたらよいでしょうか。多くの組織では、`Jenkins <https://jenkins.io/>`_ や `Atlassian Bamboo <https://www.atlassian.com/software/bamboo>`_ のような継続的統合ツールを使用して、開発、テスト、リリース、デプロイの各ステップを関連付けています。また、`Gerrit <https://www.gerritcodereview.com/>`_ のようなツールを使用して、アプリケーションコード自体か、Ansible Playbook のいずれか、または両方のコミットにコードレビューのステップを追加することもできます。

en: Depending on your environment, you might be deploying continuously to a test environment, running an integration test battery against that environment, and then deploying automatically into production.  Or you could keep it simple and just use the rolling-update for on-demand deployment into test or production specifically.  This is all up to you.
ja: 環境によっては、テスト環境に継続的にデプロイし、その環境に対して統合テストバッテリーを実行してから、実稼働環境に自動的にデプロイする場合があります。または、シンプルに保ち、ローリングアップデートを使用して、特にテスト環境または実稼働環境にオンデマンドでデプロイすることもできます。これはすべてあなた次第です。

en: For integration with Continuous Integration systems, you can easily trigger playbook runs using the ``ansible-playbook`` command line tool, or, if you're using :ref:`ansible_tower`, the ``tower-cli`` or the built-in REST API.  (The tower-cli command 'joblaunch' will spawn a remote job over the REST API and is pretty slick).
ja: 継続的統合システムとの連携では、``ansible-playbook`` コマンドラインツール (:ref:`ansible_tower` を使用している場合は、``tower-cli`` や組み込み REST API) を使用して簡単に Playbook の実行をトリガーすることができます (tower-cli コマンドの「joblaunch」は、REST API を介してリモートジョブを生成し、非常に洗練されています)。

en: This should give you a good idea of how to structure a multi-tier application with Ansible, and orchestrate operations upon that app, with the eventual goal of continuous delivery to your customers. You could extend the idea of the rolling upgrade to lots of different parts of the app; maybe add front-end web servers along with application servers, for instance, or replace the SQL database with something like MongoDB or Riak. Ansible gives you the capability to easily manage complicated environments and automate common operations.
ja: ここでは、Ansible を使用して多層アプリケーションを構築し、そのアプリケーションの操作を調整して、最終的に顧客に継続的に提供する方法を紹介しています。ローリングアップグレードの概念は、アプリケーションのさまざまな部分に広げることができます。たとえば、アプリケーションサーバーと一緒にフロントエンドの Web サーバーを追加したり、SQL データベースを MongoDB や Riak のようなものに置き換えたりすることができます。Ansible は、複雑な環境を簡単に管理し、一般的な操作を自動化する機能を提供します。

en: The lamp_haproxy example discussed here.
ja: ここで説明した lamp_haproxy の例です。

en: An introduction to playbooks
ja: Playbook の概要

en: An introduction to playbook roles
ja: Playbook のロールの概要

en: An introduction to Ansible variables
ja: Ansible 変数の概要

en: An introduction to Continuous Delivery with Ansible
ja: Ansible を使用した継続的デリバリーの概要

en: User Guide
ja: ユーザーガイド

en: **Making Open Source More Inclusive**
ja: **多様性を受け入れるオープンソースの強化**

en: Red Hat is committed to replacing problematic language in our code, documentation, and web properties. We are beginning with these four terms: master, slave, blacklist, and whitelist. We ask that you open an issue or pull request if you come upon a term that we have missed. For more details, see `our CTO Chris Wright's message <https://www.redhat.com/en/blog/making-open-source-more-inclusive-eradicating-problematic-language>`_.
ja: Red Hat では、コード、ドキュメント、Web プロパティーにおける配慮に欠ける用語の置き換えに取り組んでいます。まずは、マスター (master)、スレーブ (slave)、ブラックリスト (blacklist)、ホワイトリスト (whitelist) の 4 つの用語の置き換えから始めます。問題のある用語を見つけた場合は、問題を作成するか、プル要求を作成してください。詳細は、`弊社 の CTO、Chris Wright のメッセージ <https://www.redhat.com/en/blog/making-open-source-more-inclusive-eradicating-problematic-language>`_ を参照してください。

en: Welcome to the Ansible User Guide! This guide covers how to work with Ansible, including using the command line, working with inventory, interacting with data, writing tasks, plays, and playbooks; executing playbooks, and reference materials. This page outlines the most common situations and questions that bring readers to this section. If you prefer a traditional table of contents, you can find one at the bottom of the page.
ja: Ansible ユーザーガイドへようこそ! 本ガイドでは、コマンドラインの使用、インベントリーの操作、データの操作、タスク、プレイ、Playbook の作成、Playbook 実行、参考資料など、Ansible の使用方法について説明しています。このページでは、読者がこのセクションを訪れる時に抱く最も一般的な状況および質問の概要を説明します。従来の目次をご希望の方は、ページ下部を参照してください。

en: Getting started
ja: はじめに

en: I'd like an overview of how Ansible works. Where can I find:
ja: Ansible がどのように機能するかの概要を知りたいです。どこで見つけることができますか。

en: a :ref:`quick video overview <quickstart_guide>`
ja: a :ref:`クイックビデオの概要 <quickstart_guide>`

en: a :ref:`text introduction <intro_getting_started>`
ja: a :ref:`テキストの紹介 <intro_getting_started>`

en: I'm ready to learn about Ansible. What :ref:`basic_concepts` do I need to learn?
ja: Ansible に関する準備が整っています。どの :ref:`basic_concepts` を学ぶ必要がありますか。

en: I want to use Ansible without writing a playbook. How do I use :ref:`ad hoc commands <intro_adhoc>`?
ja: Playbook を作成せずに Ansible を使用する場合は、:ref:`ad hoc commands <intro_adhoc>` をどのように使用すればいいですか。

en: Writing tasks, plays, and playbooks
ja: タスク、プレイ、および Playbook の作成

en: I'm writing my first playbook. What should I :ref:`know before I begin <playbooks_tips_and_tricks>`?
ja: 最初の Playbook を作成します。:ref:`開始する前に学ぶ <playbooks_tips_and_tricks>` にはどうすれば良いですか。

en: I have a specific use case for a task or play:
ja: タスクまたはプレイに特定のユースケースがあります。

en: Executing tasks with elevated privileges or as a different user with :ref:`become <become>`
ja: :ref:`become <become>` を使用して、権限が昇格されたタスク、または別のユーザーとしてのタスクの実行

en: Repeating a task once for each item in a list with :ref:`loops <playbooks_loops>`
ja: :ref:`ループ <playbooks_loops>` を使用してリスト内の項目ごとにタスクを 1 度繰り返す

en: Executing tasks on a different machine with :ref:`delegation <playbooks_delegation>`
ja: :ref:`delegation <playbooks_delegation>` を使用して別のマシンでタスクを実行

en: Running tasks only when certain conditions apply with :ref:`conditionals <playbooks_conditionals>` and evaluating conditions with :ref:`tests <playbooks_tests>`
ja: :ref:`conditionals <playbooks_conditionals>` で特定の条件が適用された場合にのみタスクを実行し、:ref:`tests <playbooks_tests>` で条件を評価します。

en: Grouping a set of tasks together with :ref:`blocks <playbooks_blocks>`
ja: :ref:`blocks <playbooks_blocks>` を使用してタスクのセットをまとめる

en: Running tasks only when something has changed with :ref:`handlers <handlers>`
ja: :ref:`handlers <handlers>` を使用して変更があった場合に限りタスクを実行

en: Changing the way Ansible :ref:`handles failures <playbooks_error_handling>`
ja: Ansible が :ref:`失敗を処理する <playbooks_error_handling>` 方法の変更

en: Setting remote :ref:`environment values <playbooks_environment>`
ja: リモートの :ref:`環境値 <playbooks_environment>` の設定

en: I want to leverage the power of re-usable Ansible artifacts. How do I create re-usable :ref:`files <playbooks_reuse>` and :ref:`roles <playbooks_reuse_roles>`?
ja: 再利用可能な Ansible アーティファクトの電源を活用するには、再利用可能な :ref:`ファイル <playbooks_reuse>` および :ref:`ロール <playbooks_reuse_roles>` をどのように作成すればいいですか。

en: I need to incorporate one file or playbook inside another. What is the difference between :ref:`including and importing <dynamic_vs_static>`?
ja: あるファイルまたは Playbook を別のファイルに組み込む必要があります。:ref:`インクルードとインポート <dynamic_vs_static>` の違いは何ですか。

en: I want to run selected parts of my playbook. How do I add and use :ref:`tags <tags>`?
ja: Playbook の選択した部分を実行する場合は、:ref:`タグ <tags>` をどのように追加して使用すればいいですか。

en: Working with inventory
ja: インベントリーの使用

en: I have a list of servers and devices I want to automate. How do I create :ref:`inventory <intro_inventory>` to track them?
ja: 自動化するサーバーおよびデバイスの一覧があります。:ref:`インベントリー <intro_inventory>` を作成して追跡するにはどうすればいいですか。

en: I use cloud services and constantly have servers and devices starting and stopping. How do I track them using :ref:`dynamic inventory <intro_dynamic_inventory>`?
ja: クラウドサービスを使用し、サーバーおよびデバイスの開始および停止が常にあります。:ref:`動的インベントリー <intro_dynamic_inventory>` を使用してこれらを追跡するにはどうすればいいですか。

en: I want to automate specific sub-sets of my inventory. How do I use :ref:`patterns <intro_patterns>`?
ja: インベントリーの特定のサブセットを自動化したいです。:ref:`パターン <intro_patterns>` をどのように使用すればいいですか。

en: Interacting with data
ja: データとの対話

en: I want to use a single playbook against multiple systems with different attributes. How do I use :ref:`variables <playbooks_variables>` to handle the differences?
ja: 異なる属性を持つ複数のシステムに対して Playbook を 1 つ使用します。:ref:`変数 <playbooks_variables>` を使用して違いを処理するにはどうしたらいいですか。

en: I want to retrieve data about my systems. How do I access :ref:`Ansible facts <vars_and_facts>`?
ja: システムに関するデータを取得したいです。:ref:`Ansible ファクト <vars_and_facts>` にアクセスするにはどうすればいいですか。

en: I need to access sensitive data like passwords with Ansible. How can I protect that data with :ref:`Ansible vault <vault>`?
ja: Ansible でパスワードなどの機密データにアクセスする必要があります。:ref:`Ansible vault <vault>` でそのデータを保護するにはどうすればいいですか。

en: I want to change the data I have, so I can use it in a task. How do I use :ref:`filters <playbooks_filters>` to transform my data?
ja: データに変更を加えて、タスクで使用できるようにします。:ref:`フィルター <playbooks_filters>` を使用してデータを変換するにはどうすればよいですか。

en: I need to retrieve data from an external datastore. How do I use :ref:`lookups <playbooks_lookups>` to access databases and APIs?
ja: 外部データストアからデータを取得する必要があります。:ref:`検索 <playbooks_lookups>` を使用してデータベースおよび API にアクセスするにはどうすればいいですか。

en: I want to ask playbook users to supply data. How do I get user input with :ref:`prompts <playbooks_prompts>`?
ja: Playbook ユーザーにデータを提供するよう依頼したいです。:ref:`プロンプト <playbooks_prompts>` でユーザー入力を取得するにはどうすれば良いですか。

en: I use certain modules frequently. How do I streamline my inventory and playbooks by :ref:`setting default values for module parameters <module_defaults>`?
ja: 特定のモジュールを頻繁に使用します。:ref:`モジュールパラメーターにデフォルト値を設定 <module_defaults>` によるインベントリーと Playbook をストリーミングするにはどうすれば良いですか。

en: Executing playbooks
ja: Playbook の実行

en: Once your playbook is ready to run, you may need to use these topics:
ja: Playbook の実行準備ができたら、以下のトピックを使用する必要があります。

en: Executing "dry run" playbooks with :ref:`check mode and diff <check_mode_dry>`
ja: :ref:`確認モードおよび差異モード <check_mode_dry>` で「ドライラン」Playbook の実行

en: Running playbooks while troubleshooting with :ref:`start and step <playbooks_start_and_step>`
ja: :ref:`start および step <playbooks_start_and_step>` を使用したトラブルシューティング時の Playbook の実行

en: Correcting tasks during execution with the :ref:`Ansible debugger <playbook_debugger>`
ja: :ref:`Ansible デバッガ― <playbook_debugger>` で実行時のタスクの修正

en: Controlling how my playbook executes with :ref:`strategies and more <playbooks_strategies>`
ja: :ref:`ストラテジーなど <playbooks_strategies>` を使用した Playbook の実行方法の制御

en: Running tasks, plays, and playbooks :ref:`asynchronously <playbooks_async>`
ja: タスク、プレイ、および Playbook を :ref:`非同期に <playbooks_async>` の実行

en: Advanced features and reference
ja: 高度な機能および参照

en: Using :ref:`advanced syntax <playbooks_advanced_syntax>`
ja: :ref:`高度な構文 <playbooks_advanced_syntax>` の使用

en: Manipulating :ref:`complex data <complex_data_manipulation>`
ja: :ref:`複雑なデータ <complex_data_manipulation>` の処理

en: Using :ref:`plugins <plugins_lookup>`
ja: :ref:`プラグイン <plugins_lookup>` の使用

en: Using :ref:`playbook keywords <playbook_keywords>`
ja: :ref:`Playbook キーワード <playbook_keywords>` の使用

en: Using :ref:`command-line tools <command_line_tools>`
ja: :ref:`コマンドラインツール <command_line_tools>` の使用

en: Rejecting :ref:`specific modules <plugin_filtering_config>`
ja: :ref:`特定モジュール <plugin_filtering_config>` の拒否

en: Module :ref:`maintenance <modules_support>`
ja: モジュールの :ref:`保守 <modules_support>`

en: Traditional Table of Contents
ja: 従来の目次

en: If you prefer to read the entire User Guide, here's a list of the pages in order:
ja: 本ユーザーガイドをすべて読む場合は、以下に示す順番でページを表示してください。

en: Introduction
ja: はじめに

en: Before we start exploring the main components of Ansible -- playbooks, configuration management, deployment, and orchestration -- we'll learn how to get Ansible installed and cover some basic concepts.  We'll also go over how to execute ad hoc commands in parallel across your nodes using /usr/bin/ansible, and see what modules are available in Ansible's core (you can also write your own, which is covered later).
ja: ここでは、Ansible の主なコンポーネントである Playbook、構成管理、デプロイメント、オーケストレーションについて説明しますが、その前に、Ansible のインストール方法と基本的な概念について説明します。また、/usr/bin/ansible を使用してノード間でアドホックコマンドを並列実行する方法や、Ansible のコアにはどのようなモジュールが用意されているかを見ていきます (自分で作成することもできますが、これは後で説明します)。

en: Introduction to ad hoc commands
ja: アドホックコマンドの概要

en: An Ansible ad hoc command uses the `/usr/bin/ansible` command-line tool to automate a single task on one or more managed nodes. ad hoc commands are quick and easy, but they are not reusable. So why learn about ad hoc commands first? ad hoc commands demonstrate the simplicity and power of Ansible. The concepts you learn here will port over directly to the playbook language. Before reading and executing these examples, please read :ref:`intro_inventory`.
ja: Ansible アドホックコマンドは、`/usr/bin/ansible` コマンドラインツールを使用して、1 つまたは複数の管理ノード上の単一タスクを自動化します。アドホックコマンドは素早く簡単に実行できますが、再利用はできません。では、なぜ最初にアドホックコマンドを学ぶのかというと、アドホックコマンドは Ansible の簡易さと性能を実証するものだからです。ここで学んだ概念は、そのまま Playbook 言語に移植されます。これらの例を読んで実行する前に、「:ref:`intro_inventory`」を参照してください。

en: Why use ad hoc commands?
ja: アドホックコマンドを使用する理由

en: ad hoc commands are great for tasks you repeat rarely. For example, if you want to power off all the machines in your lab for Christmas vacation, you could execute a quick one-liner in Ansible without writing a playbook. An ad hoc command looks like this:
ja: アドホックコマンドは、めったに繰り返さないタスクに最適です。たとえば、クリスマス休暇中に研究室のすべてのマシンの電源を切りたい場合は、Playbook を作成せず、Ansible で 1 行の簡単なコマンドを実行できます。アドホックコマンドは次のようなものです。

en: You can learn more about :ref:`patterns<intro_patterns>` and :ref:`modules<working_with_modules>` on other pages.
ja: 他のページで、:ref:`パターン<intro_patterns>` や :ref:`モジュール<working_with_modules>` の詳細を確認できます。

en: Use cases for ad hoc tasks
ja: アドホックタスクのユースケース

en: ad hoc tasks can be used to reboot servers, copy files, manage packages and users, and much more. You can use any Ansible module in an ad hoc task. ad hoc tasks, like playbooks, use a declarative model, calculating and executing the actions required to reach a specified final state. They achieve a form of idempotence by checking the current state before they begin and doing nothing unless the current state is different from the specified final state.
ja: アドホックタスクは、サーバーの再起動、ファイルのコピー、パッケージやユーザーの管理など、さまざまな用途に使用できます。Ansible モジュールはアドホックタスクで使用できます。アドホックタスクは、Playbook と同様に、宣言型モデルを使用し、指定された最終状態に到達するために必要なアクションを計算して実行します。アドホックタスクは、開始前に現在の状態をチェックし、現在の状態が指定された最終状態と異なる場合を除いて何もしないことで、一種の冪等性を実現しています。

en: Rebooting servers
ja: サーバーの再起動

en: The default module for the ``ansible`` command-line utility is the :ref:`ansible.builtin.command module<command_module>`. You can use an ad hoc task to call the command module and reboot all web servers in Atlanta, 10 at a time. Before Ansible can do this, you must have all servers in Atlanta listed in a group called [atlanta] in your inventory, and you must have working SSH credentials for each machine in that group. To reboot all the servers in the [atlanta] group:
ja: ``ansible`` コマンドラインユーティリティーのデフォルトモジュールは、:ref:`ansible.builtin.command module<command_module>` です。アドホックタスクを使用してコマンドモジュールを呼び出し、Atlanta のすべての Web サーバを一度に 10 台ずつ再起動することができます。Ansible がこれを行う前に、インベントリー内の [atlanta] というグループに Atlanta にあるすべてのサーバーが記載されている必要があり、そのグループ内の各マシンの SSH 認証情報が有効でなければなりません。[atlanta] グループのすべてのサーバーを再起動するには、次のようにします。

en: By default Ansible uses only 5 simultaneous processes. If you have more hosts than the value set for the fork count, Ansible will talk to them, but it will take a little longer. To reboot the [atlanta] servers with 10 parallel forks:
ja: デフォルトでは、Ansible は 5 つの同時プロセスのみを使用します。フォーク数に設定された値よりも多くのホストがある場合、Ansible はそれらのホストと対話しますが、少し時間がかかります。10 個の並列フォークで [atlanta] サーバーを再起動する場合は、以下のようにします。

en: /usr/bin/ansible will default to running from your user account. To connect as a different user:
ja: usr/bin/ansible はデフォルトで自身のユーザーアカウントから実行されます。別のユーザーとして接続するには、以下を行います。

en: Rebooting probably requires privilege escalation. You can connect to the server as ``username`` and run the command as the ``root`` user by using the :ref:`become <become>` keyword:
ja: 再起動には、おそらく権限昇格が必要です。``username`` としてサーバーに接続し、:ref:`become <become>` キーワードを使用して ``root`` ユーザーとしてコマンドを実行できます。

en: If you add ``--ask-become-pass`` or ``-K``, Ansible prompts you for the password to use for privilege escalation (sudo/su/pfexec/doas/etc).
ja: ``--ask-become-pass`` または ``-K`` を追加します。Ansible により、権限昇格に使用するパスワード (sudo/su/pfexec/doas など) の入力が求められます。

en: The :ref:`command module <command_module>` does not support extended shell syntax like piping and redirects (although shell variables will always work). If your command requires shell-specific syntax, use the `shell` module instead. Read more about the differences on the :ref:`working_with_modules` page.
ja: :ref:`command module <command_module>` は、piping や redirects のような拡張シェル構文をサポートしていません (ただし、シェル変数は常に動作します)。シェル特有の構文を必要とするコマンドの場合は、代わりに `shell` モジュールを使用してください。その違いについては「:ref:`working_with_modules`」のページをご覧ください。

en: So far all our examples have used the default 'command' module. To use a different module, pass ``-m`` for module name. For example, to use the :ref:`ansible.builtin.shell module <shell_module>`:
ja: この例では、デフォルトの「command」モジュールを使用しています。別のモジュールを使用するには、モジュール名に ``-m`` を渡します。たとえば、:ref:`ansible.builtin.shell module <shell_module>` を使用します。

en: When running any command with the Ansible *ad hoc* CLI (as opposed to :ref:`Playbooks <working_with_playbooks>`), pay particular attention to shell quoting rules, so the local shell retains the variable and passes it to Ansible. For example, using double rather than single quotes in the above example would evaluate the variable on the box you were on.
ja: (:ref:`Playbooks <working_with_playbooks>` とは異なり) Ansible の *アドホック* CLI を使用してコマンドを実行する場合は、ローカルシェルが変数を保持して Ansible に渡すように、シェルの引用規則に特に注意してください。たとえば、上記の例で一重引用符ではなく二重引用符を使用すると、指定しているそのボックスの変数が評価されます。

en: Managing files
ja: ファイルの管理

en: An ad hoc task can harness the power of Ansible and SCP to transfer many files to multiple machines in parallel. To transfer a file directly to all servers in the [atlanta] group:
ja: アドホックタスクでは、Ansible と SCP の力を利用して、多数のファイルを複数のマシンに並行して転送することができます。[atlanta] グループのすべてのサーバーに直接ファイルを転送するには、次のようにします。

en: If you plan to repeat a task like this, use the :ref:`ansible.builtin.template<template_module>` module in a playbook.
ja: このようなタスクを繰り返す場合は、Playbook で :ref:`ansible.builtin.template<template_module>` モジュールを使用します。

en: The :ref:`ansible.builtin.file<file_module>` module allows changing ownership and permissions on files. These same options can be passed directly to the ``copy`` module as well:
ja: :ref:`ansible.builtin.file<file_module>` モジュールにより、ファイルの所有権およびパーミッションを変更できます。同じオプションを ``copy`` モジュールに直接渡すことができます。

en: The ``file`` module can also create directories, similar to ``mkdir -p``:
ja: ``file`` モジュールは、``mkdir -p`` と同様、ディレクトリーも作成できます。

en: As well as delete directories (recursively) and delete files:
ja: ディレクトリーを (再帰的に) 削除し、ファイルを削除します。

en: Managing packages
ja: パッケージの管理

en: You might also use an ad hoc task to install, update, or remove packages on managed nodes using a package management module like yum. To ensure a package is installed without updating it:
ja: また、yum などのパッケージ管理モジュールを使用して、管理対象のノードにパッケージをインストール、アップデート、または削除するアドホックタスクを使用することもあります。パッケージを更新せずに確実にインストールするには、以下を行います。

en: To ensure a specific version of a package is installed:
ja: パッケージの特定バージョンがインストールされていることを確認するには、次のコマンドを実行します。

en: To ensure a package is at the latest version:
ja: パッケージが最新バージョンであることを確認するには、次のコマンドを実行します。

en: To ensure a package is not installed:
ja: パッケージがインストールされていないことを確認するには、次のコマンドを実行します。

en: Ansible has modules for managing packages under many platforms. If there is no module for your package manager, you can install packages using the command module or create a module for your package manager.
ja: Ansible には、多くのプラットフォームでパッケージを管理するためのモジュールが用意されています。お使いのパッケージマネージャー用のモジュールがない場合は、コマンドモジュールを使用してパッケージをインストールするか、パッケージマネージャー用のモジュールを作成してください。

en: Managing users and groups
ja: ユーザーおよびグループの管理

en: You can create, manage, and remove user accounts on your managed nodes with ad hoc tasks:
ja: アドホックタスクを使用すると、管理ノードでユーザーアカウントを作成、管理、および削除できます。

en: See the :ref:`ansible.builtin.user <user_module>` module documentation for details on all of the available options, including how to manipulate groups and group membership.
ja: グループやグループメンバーシップの操作方法など、利用可能なすべてのオプションの詳細は、:ref:`ansible.builtin.user <user_module>` モジュールのドキュメントを参照してください。

en: Managing services
ja: サービスの管理

en: Ensure a service is started on all webservers:
ja: サービスがすべての Web サーバーで起動していることを確認します。

en: Alternatively, restart a service on all webservers:
ja: または、すべての Web サーバーでサービスを再起動します。

en: Ensure a service is stopped:
ja: サービスが停止していることを確認します。

en: Gathering facts
ja: ファクトの収集

en: Facts represent discovered variables about a system. You can use facts to implement conditional execution of tasks but also just to get ad hoc information about your systems. To see all facts:
ja: ファクトは、検出されたシステムに関する変数を表します。ファクトを使用して、タスクの条件付き実行を実装することもできますが、システムに関するアドホック情報を取得することもできます。すべてのファクトを表示するには、以下を実行します。

en: You can also filter this output to display only certain facts, see the :ref:`ansible.builtin.setup <setup_module>` module documentation for details.
ja: この出力をフィルターで絞り込んで、特定のファクトのみを表示することもできます。詳細は :ref:`ansible.builtin.setup <setup_module>` モジュールのドキュメントを参照してください。

en: Now that you understand the basic elements of Ansible execution, you are ready to learn to automate repetitive tasks using :ref:`Ansible Playbooks <playbooks_intro>`.
ja: これで、Ansible を実行する基本要素を理解し、:ref:`Ansible Playbooks <playbooks_intro>` を使用して反復タスクを自動化する方法を学ぶ準備が整いました。

en: All about the Ansible config file
ja: Ansible 設定ファイルの詳細

en: Browse existing collections, modules, and plugins
ja: 既存のコレクション、モジュール、およびプラグインの閲覧

en: Using Ansible for configuration management & deployment
ja: 設定管理およびデプロイメントに Ansible の使用

en: Ansible and BSD
ja: Ansible および BSD

en: Managing BSD machines is different from managing other Unix-like machines. If you have managed nodes running BSD, review these topics.
ja: BSD マシンの管理は、他の Unix 系マシンの管理とは異なります。BSD を実行している管理ノードを使用している場合は、以下のトピックを確認してください。

en: Connecting to BSD nodes
ja: BSD ノードへの接続

en: Ansible connects to managed nodes using OpenSSH by default. This works on BSD if you use SSH keys for authentication. However, if you use SSH passwords for authentication, Ansible relies on sshpass. Most versions of sshpass do not deal well with BSD login prompts, so when using SSH passwords against BSD machines, use ``paramiko`` to connect instead of OpenSSH. You can do this in ansible.cfg globally or you can set it as an inventory/group/host variable. For example:
ja: Ansible はデフォルトで OpenSSH を使用して管理ノードに接続します。これは、認証に SSH 鍵を使用している場合は BSD で動作します。ただし、認証に SSH パスワードを使用する場合、Ansible は sshpass に依存します。sshpass のほとんどのバージョンは BSD のログインプロンプトにうまく対応できません。したがって、BSD マシンに対して SSH パスワードを使用する場合は、OpenSSH の代わりに ``paramiko`` を使用して接続してください。これは ansible.cfg でグローバルに行うこともできますし、inventory/group/host 変数として設定することもできます。以下に例を示します。

en: Bootstrapping BSD
ja: BSD のブートストラップ

en: Ansible is agentless by default, however, it requires Python on managed nodes. Only the :ref:`raw <raw_module>` module will operate without Python. Although this module can be used to bootstrap Ansible and install Python on BSD variants (see below), it is very limited and the use of Python is required to make full use of Ansible's features.
ja: Ansible はデフォルトでエージェントレスですが、管理ノードで Python が必要になります。:ref:`raw <raw_module>` モジュールのみが Python なしで動作します。このモジュールを使用して Ansible をブートストラップして BSD バリアントに Python をインストールできます (下記参照) が、Python は非常に制限されており、Ansible の機能を完全に活用するには Python を使用する必要があります。

en: The following example installs Python 2.7 which includes the json library required for full functionality of Ansible. On your control machine you can execute the following for most versions of FreeBSD:
ja: 次の例では、Ansible の完全な機能に必要な json ライブラリーを含む Python 2.7 をインストールしています。コントロールマシンでは、ほとんどのバージョンの FreeBSD で次のように実行できます。

en: Or for OpenBSD:
ja: OpenBSD の場合は、次のコマンドを使用します。

en: Once this is done you can now use other Ansible modules apart from the ``raw`` module.
ja: これが完了すると、``raw`` モジュール以外の他の Ansible モジュールを使用できるようになります。

en: This example demonstrated using pkg on FreeBSD and pkg_add on OpenBSD, however you should be able to substitute the appropriate package tool for your BSD; the package name may also differ. Refer to the package list or documentation of the BSD variant you are using for the exact Python package name you intend to install.
ja: この例では、FreeBSD では pkg を、OpenBSD では pkg_add を使用していますが、お使いの BSD に合わせて適切なパッケージツールを選択してください。また、パッケージ名も異なる場合があります。インストールする Python パッケージ名については、使用している BSD のパッケージリストやドキュメントを参照してください。

en: Setting the Python interpreter
ja: Python インタープリターの設定

en: To support a variety of Unix-like operating systems and distributions, Ansible cannot always rely on the existing environment or ``env`` variables to locate the correct Python binary. By default, modules point at ``/usr/bin/python`` as this is the most common location. On BSD variants, this path may differ, so it is advised to inform Ansible of the binary's location, through the ``ansible_python_interpreter`` inventory variable. For example:
ja: さまざまな Unix 系オペレーティングシステムやディストリビューションをサポートするために、Ansible は常に既存の環境変数や ``env`` 変数を頼りに正しい Python バイナリーを探すことはできません。デフォルトでは、モジュールは最も一般的な場所である ``/usr/bin/python`` を指します。BSD 系では、このパスが異なる場合があるので、``ansible_python_interpreter`` インベントリー変数を使用して、バイナリーの場所を Ansible に知らせることが推奨されます。以下に例を示します。

en: If you use additional plugins beyond those bundled with Ansible, you can set similar variables for ``bash``, ``perl`` or ``ruby``, depending on how the plugin is written. For example:
ja: Ansible でバンドルされているプラグイン以外のプラグインを使用する場合は、プラグインの記述方法に応じて ``bash``、``perl``、または ``ruby`` に同様の変数を設定できます。

en: Which modules are available?
ja: 利用可能なモジュール

en: The majority of the core Ansible modules are written for a combination of Unix-like machines and other generic services, so most should function well on the BSDs with the obvious exception of those that are aimed at Linux-only technologies (such as LVG).
ja: Ansible のコアモジュールの大半は、Unix 系マシンと他の汎用サービスを組み合わせて記述されているため、Linux に限定したテクノロジー (LVG など) を対象とするものを除き、その大半が BSD 上で正常に機能します。

en: Using BSD as the control node
ja: コントロールノードとしての BSD の使用

en: Using BSD as the control machine is as simple as installing the Ansible package for your BSD variant or by following the ``pip`` or 'from source' instructions.
ja: BSD をコントロールマシンとして使用することは、BSD バリアントの Ansible パッケージをインストールするか、``pip`` または「from source」の指示に従うのと同じくらい簡単です。

en: BSD facts
ja: BSD ファクト

en: Ansible gathers facts from the BSDs in a similar manner to Linux machines, but since the data, names and structures can vary for network, disks and other devices, one should expect the output to be slightly different yet still familiar to a BSD administrator.
ja: Ansible は、Linux マシンと同様の方法で BSD からファクトを収集しますが、データ、名前、構造は、ネットワーク、ディスク、およびその他のデバイスにより異なる可能性があるため、BSD 管理者にとっては出力が多少異なるもののまだ馴染みがあることが期待できます。

en: BSD efforts and contributions
ja: BSD の取り組みおよび貢献

en: BSD support is important to us at Ansible. Even though the majority of our contributors use and target Linux we have an active BSD community and strive to be as BSD-friendly as possible. Please feel free to report any issues or incompatibilities you discover with BSD; pull requests with an included fix are also welcome!
ja: BSD サポートは Ansible にとって重要です。貢献者の大半は Linux を使用していますが、Ansible には活発な BSD コミュニティーがあり、可能な限り BSD フレンドリーであるように努めています。BSD に関する問題や非互換性を発見した場合は、遠慮なくご報告ください。

en: Examples of basic commands
ja: 基本コマンドの例

en: Learning ansible's configuration management language
ja: Ansible の設定管理言語の概要

en: How to write modules
ja: モジュールの書き方

en: Working with dynamic inventory
ja: 動的インベントリーの使用

en: If your Ansible inventory fluctuates over time, with hosts spinning up and shutting down in response to business demands, the static inventory solutions described in :ref:`inventory` will not serve your needs. You may need to track hosts from multiple sources: cloud providers, LDAP, `Cobbler <https://cobbler.github.io>`_, and/or enterprise CMDB systems.
ja: Ansible のインベントリーが、ビジネス上の要求に応じてホストの回転や停止など、時間とともに変動する場合は、:ref:`inventory` で説明している静的なインベントリーソリューションではニーズに応えられません。クラウドプロバイダー、LDAP、`Cobbler <https://cobbler.github.io>`_、エンタープライズ CMDB システムなど、複数のソースからのホストの追跡が必要になる場合があります。

en: Ansible integrates all of these options through a dynamic external inventory system. Ansible supports two ways to connect with external inventory:  :ref:`inventory_plugins` and `inventory scripts`.
ja: Ansible は、動的な外部インベントリーシステムを通じて、これらのオプションをすべて統合します。Ansible は、外部インベントリーに接続する 2 つの方法 (:ref:`inventory_plugins` および `inventory scripts`) をサポートしています。

en: Inventory plugins take advantage of the most recent updates to the Ansible core code. We recommend plugins over scripts for dynamic inventory. You can :ref:`write your own plugin <developing_inventory>` to connect to additional dynamic inventory sources.
ja: インベントリープラグインは、Ansible コアコードの最新の更新を利用しています。動的インベントリーには、スクリプトよりもプラグインが推奨されます。:ref:`独自のプラグインを記述 <developing_inventory>` して、追加の動的インベントリーソースに接続することができます。

en: You can still use inventory scripts if you choose. When we implemented inventory plugins, we ensured backwards compatibility through the script inventory plugin. The examples below illustrate how to use inventory scripts.
ja: また、インベントリースクリプトを使用することもできます。インベントリープラグインを実装する際に、スクリプトインベントリープラグインによる後方互換性を確保しました。以下の例では、インベントリースクリプトの使用方法を説明しています。

en: If you prefer a GUI for handling dynamic inventory, the :ref:`ansible_tower` inventory database syncs with all your dynamic inventory sources, provides web and REST access to the results, and offers a graphical inventory editor. With a database record of all of your hosts, you can correlate past event history and see which hosts have had failures on their last playbook runs.
ja: 動的インベントリーを GUI で操作したい場合は、:ref:`ansible_tower` インベントリーデータベースがすべての動的インベントリーソースと同期し、その結果に Web および REST アクセスを提供し、グラフィカルインベントリーエディターを提供します。すべてのホストのデータベースレコードを使用して、過去のイベント履歴を関連付け、最後の Playbook の実行でどのホストに障害が発生したかを確認できます。

en: Inventory script example: Cobbler
ja: インベントリースクリプトの例: Cobbler

en: Ansible integrates seamlessly with `Cobbler <https://cobbler.github.io>`_, a Linux installation server originally written by Michael DeHaan and now led by James Cammarata, who works for Ansible.
ja: Ansible は、Linux インストールサーバー `Cobbler <https://cobbler.github.io>`_ (最初に Michael DeHaan 氏が作成し、現在は Ansible に所属する James Cammarata が率いています) とシームレスに統合されます。

en: While primarily used to kickoff OS installations and manage DHCP and DNS, Cobbler has a generic layer that can represent data for multiple configuration management systems (even at the same time) and serve as a 'lightweight CMDB'.
ja: Cobbler は主に OS のインストールを開始し、DHCP と DNS を管理するために使用されますが、複数の構成管理システムのデータを (同時にでも) 表現し、「軽量CMDB」として機能する汎用レイヤーがあります。

en: To tie your Ansible inventory to Cobbler, copy `this script <https://raw.githubusercontent.com/ansible-community/contrib-scripts/main/inventory/cobbler.py>`_ to ``/usr/local/etc/ansible`` and ``chmod +x`` the file. Run ``cobblerd`` any time you use Ansible and use the ``-i`` command line option (for example, ``-i /usr/local/etc/ansible/cobbler.py``) to communicate with Cobbler using Cobbler's XMLRPC API.
ja: Ansible インベントリーを Cobbler に関連付けるには、`このスクリプト <https://raw.githubusercontent.com/ansible-community/contrib-scripts/main/inventory/cobbler.py>`_ を ``/usr/local/etc/ansible`` にコピーして、コピーしたファイルに ``chmod +x`` を付与します。Ansible を使用して ``cobblerd`` を実行し、``-i`` コマンドラインオプション (例: ``-i /usr/local/etc/ansible/cobbler.py``) を付けて、Cobbler の XMLRPC API 使用して Cobbler と通信します。

en: Add a ``cobbler.ini`` file in ``/usr/local/etc/ansible`` so Ansible knows where the Cobbler server is and some cache improvements can be used. For example:
ja: Ansible が Cobbler サーバーの場所とキャッシュの改良に使用できるものを認識できるように、``/usr/local/etc/ansible`` に ``cobbler.ini`` ファイルを追加します。以下に例を示します。

en: First test the script by running ``/usr/local/etc/ansible/cobbler.py`` directly. You should see some JSON data output, but it may not have anything in it just yet.
ja: まず ``/usr/local/etc/ansible/cobbler.py`` を直接実行してスクリプトをテストします。JSON データ出力が表示されますが、まだ何も含まれていない場合もあります。

en: Let's explore what this does.  In Cobbler, assume a scenario somewhat like the following:
ja: これで何ができるのか見てみましょう。Cobbler で、次のようなシナリオを想定します。

en: In the example above, the system 'foo.example.com' is addressable by ansible directly, but is also addressable when using the group names 'webserver' or 'atlanta'. Since Ansible uses SSH, it contacts system foo over 'foo.example.com', only, never just 'foo'. Similarly, if you tried "ansible foo", it would not find the system... but "ansible 'foo*'" would do, because the system DNS name starts with 'foo'.
ja: 上の例では、システム「foo.example.com」は、ansible が直接アドレスを指定できるだけでなく、グループ名「webserver」や「atlanta」を使用してもアドレスを指定できます。Ansible は SSH を使用しているため、「foo.example.com」を経由してシステム foo に接続しますが、決して「foo」だけではありません。同様に、「ansible foo」と入力しても、システムを見つけることはできませんが、「ansible 'foo'*」と入力すると、システムの DNS 名が 'foo' で始まるため、システムを見つけることができます。

en: The script provides more than host and group info. In addition, as a bonus, when the 'setup' module is run (which happens automatically when using playbooks), the variables 'a', 'b', and 'c' will all be auto-populated in the templates:
ja: このスクリプトは、ホストとグループの情報以外にもさまざまな情報を提供します。さらに、(Playbook を使用する際に自動的に実行される)「setup」モジュールを実行すると、変数「a」、「b」、および「c」はすべてテンプレートに自動入力されるようになります。

en: Which could be executed just like this:
ja: これは以下のように実行できます。

en: The name 'webserver' came from Cobbler, as did the variables for the config file.  You can still pass in your own variables like normal in Ansible, but variables from the external inventory script will override any that have the same name.
ja: 「webserver」という名前は、設定ファイルの変数と同様に、Cobbler から来ています。Ansible では通常のように独自の変数を渡すことができますが、外部のインベントリースクリプトからの変数は、同じ名前のものを上書きします。

en: So, with the template above (``motd.j2``), this results in the following data being written to ``/etc/motd`` for system 'foo':
ja: そのため、上記のテンプレート (``motd.j2``) を使用すると、以下のデータがシステム「foo」用に ``/etc/motd`` に書き込まれます。

en: And on system 'bar' (bar.example.com):
ja: システム「bar」(bar.example.com) は、以下のようになります。

en: And technically, though there is no major good reason to do it, this also works:
ja: 技術的には、これを行う大きな正当な理由はありませんが、これも機能します。

en: So, in other words, you can use those variables in arguments/actions as well.
ja: つまり、引数やアクションでこの変数を使用することもできます。

en: Inventory script example: OpenStack
ja: インベントリースクリプトの例: OpenStack

en: If you use an OpenStack-based cloud, instead of manually maintaining your own inventory file, you can use the ``openstack_inventory.py`` dynamic inventory to pull information about your compute instances directly from OpenStack.
ja: 独自のインベントリーファイルを手動で管理する代わりに、OpenStack ベースのクラウドを使用する場合は、動的インベントリー ``openstack_inventory.py`` を使用して、OpenStack から直接 Compute インスタンスに関する情報を取得できます。

en: You can download the latest version of the OpenStack inventory script `here <https://raw.githubusercontent.com/openstack/ansible-collections-openstack/master/scripts/inventory/openstack_inventory.py>`_.
ja: 最新バージョンの OpenStack インベントリースクリプトは、`こちら <https://raw.githubusercontent.com/openstack/ansible-collections-openstack/master/scripts/inventory/openstack_inventory.py>`_ からダウンロードできます。

en: You can use the inventory script explicitly (by passing the `-i openstack_inventory.py` argument to Ansible) or implicitly (by placing the script at `/usr/local/etc/ansible/hosts`).
ja: (`-i openstack_inventory.py` 引数を Ansible に渡すことで) インベントリースクリプトを明示的に使用するか、(スクリプトを `/usr/local/etc/ansible/hosts` において) 暗黙的に使用できます。

en: Explicit use of OpenStack inventory script
ja: OpenStack インベントリースクリプトの明示的な使用

en: Download the latest version of the OpenStack dynamic inventory script and make it executable::
ja: 最新バージョンの OpenStack の動的インベントリースクリプトをダウンロードし、実行可能にします。

en: Do not name it `openstack.py`. This name will conflict with imports from openstacksdk.
ja: `openstack.py` という名前はつけないでください。この名前は、openstacksdk からのインポートと競合します。

en: Source an OpenStack RC file:
ja: OpenStack RC ファイルを読み込みます。

en: An OpenStack RC file contains the environment variables required by the client tools to establish a connection with the cloud provider, such as the authentication URL, user name, password and region name. For more information on how to download, create or source an OpenStack RC file, please refer to `Set environment variables using the OpenStack RC file <https://docs.openstack.org/user-guide/common/cli_set_environment_variables_using_openstack_rc.html>`_.
ja: OpenStack RC ファイルには、認証 URL、ユーザー名、パスワード、リージョン名など、クラウドプロバイダーとの接続を確立するためにクライアントツールで必要な環境変数が含まれています。OpenStack RC ファイルのダウンロード、作成、またはソースに関する詳細は、「`Set environment variables using the OpenStack RC file <https://docs.openstack.org/user-guide/common/cli_set_environment_variables_using_openstack_rc.html>`_」を参照してください。

en: You can confirm the file has been successfully sourced by running a simple command, such as `nova list` and ensuring it returns no errors.
ja: `nova list` などの単純なコマンドを実行してエラーを返さないようにすることで、ファイルが正常に読み込まれたことを確認できます。

en: The OpenStack command line clients are required to run the `nova list` command. For more information on how to install them, please refer to `Install the OpenStack command-line clients <https://docs.openstack.org/user-guide/common/cli_install_openstack_command_line_clients.html>`_.
ja: `nova list` コマンドを実行するには、OpenStack コマンドラインクライアントが必要です。インストール方法の詳細は、「`Install the OpenStack command-line clients <https://docs.openstack.org/user-guide/common/cli_install_openstack_command_line_clients.html>`_」を参照してください。

en: You can test the OpenStack dynamic inventory script manually to confirm it is working as expected::
ja: OpenStack の動的インベントリースクリプトを手動でテストして、想定どおりに機能していることを確認します。

en: After a few moments you should see some JSON output with information about your compute instances.
ja: しばらくすると、Compute インスタンスに関する情報が含まれる JSON 出力が表示されます。

en: Once you confirm the dynamic inventory script is working as expected, you can tell Ansible to use the `openstack_inventory.py` script as an inventory file, as illustrated below:
ja: 動的インベントリースクリプトが想定どおりに機能していることを確認したら、以下のように Ansible が `openstack_inventory.py` スクリプトをインベントリーファイルとして使用するように指定します。

en: Implicit use of OpenStack inventory script
ja: OpenStack インベントリースクリプトの暗黙的な使用

en: Download the latest version of the OpenStack dynamic inventory script, make it executable and copy it to `/usr/local/etc/ansible/hosts`:
ja: 最新バージョンの OpenStack 動的インベントリースクリプトをダウンロードし、実行可能にし、これを `/usr/local/etc/ansible/hosts` にコピーします。

en: Download the sample configuration file, modify it to suit your needs and copy it to `/usr/local/etc/ansible/openstack.yml`:
ja: サンプル設定ファイルをダウンロードし、必要に応じて変更し、これを `/usr/local/etc/ansible/openstack.yml` にコピーします。

en: You can test the OpenStack dynamic inventory script manually to confirm it is working as expected:
ja: OpenStack 動的インベントリースクリプトを手動でテストして、想定どおりに機能していることを確認します。

en: Refreshing the cache
ja: キャッシュの更新

en: Note that the OpenStack dynamic inventory script will cache results to avoid repeated API calls. To explicitly clear the cache, you can run the openstack_inventory.py (or hosts) script with the ``--refresh`` parameter:
ja: OpenStack 動的インベントリースクリプトは、API 呼び出しが繰り返し行われるのを防ぐために、結果をキャッシュすることに注意してください。キャッシュを明示的に消去するには、``--refresh`` パラメーターを使用して openstack_inventory.py (または hosts) スクリプトを実行します。

en: Other inventory scripts
ja: その他のインベントリースクリプト

en: In Ansible 2.10 and later, inventory scripts moved to their associated collections. Many are now in the `community.general scripts/inventory directory <https://github.com/ansible-collections/community.general/tree/main/scripts/inventory>`_. We recommend you use :ref:`inventory_plugins` instead.
ja: Ansible 2.10 以降では、インベントリースクリプトは関連するコレクションに移動しました。現在、多くのスクリプトは `community.general scripts/inventory directory <https://github.com/ansible-collections/community.general/tree/main/scripts/inventory>`_ にあります。代わりに :ref:`inventory_plugins` を使用することが推奨されます。

en: Using inventory directories and multiple inventory sources
ja: インベントリーディレクトリーおよび複数のインベントリーソースの使用

en: If the location given to ``-i`` in Ansible is a directory (or as so configured in ``ansible.cfg``), Ansible can use multiple inventory sources at the same time.  When doing so, it is possible to mix both dynamic and statically managed inventory sources in the same ansible run. Instant hybrid cloud!
ja: Ansible で ``-i`` に指定される場所がディレクトリーの場合 (または ``ansible.cfg`` でそのように設定されている場合)、Ansible は複数のインベントリーソースを同時に使用できます。これを実行する場合は、同じ Ansible 実行で動的および静的に管理されているインベントリーソースを混在させることができます。

en: In an inventory directory, executable files are treated as dynamic inventory sources and most other files as static sources. Files which end with any of the following are ignored:
ja: インベントリーディレクトリでは、実行ファイルは動的インベントリーソースとして、その他のほとんどのファイルは静的ソースとして扱われます。以下のいずれかで終わるファイルは無視されます。

en: You can replace this list with your own selection by configuring an ``inventory_ignore_extensions`` list in ``ansible.cfg``, or setting the :envvar:`ANSIBLE_INVENTORY_IGNORE` environment variable. The value in either case must be a comma-separated list of patterns, as shown above.
ja: この一覧は、``ansible.cfg`` で ``inventory_ignore_extensions`` 一覧を設定するか、:envvar:`ANSIBLE_INVENTORY_IGNORE` 環境変数を設定して独自の選択に置き換えることができます。いずれの値も、上記のようにパターンのコンマ区切りの一覧である必要があります。

en: Any ``group_vars`` and ``host_vars`` subdirectories in an inventory directory are interpreted as expected, making inventory directories a powerful way to organize different sets of configurations. See :ref:`using_multiple_inventory_sources` for more information.
ja: インベントリーディレクトリーの ``group_vars`` サブディレクトリーおよび ``host_vars`` サブディレクトリーは想定どおりに解釈されるため、インベントリーディレクトリーはさまざまな構成セットを整理するための強力な方法になります。詳細は、「:ref:`using_multiple_inventory_sources`」を参照してください。

en: Static groups of dynamic groups
ja: 動的グループの静的グループ

en: When defining groups of groups in the static inventory file, the child groups must also be defined in the static inventory file, otherwise ansible returns an error. If you want to define a static group of dynamic child groups, define the dynamic groups as empty in the static inventory file. For example:
ja: 静的インベントリーファイルでグループのグループを定義する場合は、子グループも静的インベントリーファイルで定義されていなければ、Ansible はエラーを返します。動的な子グループの静的グループを定義する場合は、静的インベントリーファイルで動的グループを空に定義してください。以下に例を示します。

en: All about static inventory files
ja: 静的インベントリーファイルの詳細

en: Getting Started
ja: はじめに

en: Now that you have read the :ref:`installation guide<installation_guide>` and installed Ansible on a control node, you are ready to learn how Ansible works. A basic Ansible command or playbook:
ja: 「:ref:`インストールガイド<installation_guide>`」を読み、コントロールノードに Ansible をインストールしたら、Ansible の仕組みを学ぶ準備ができました。基本的な Ansible のコマンドや Playbook です。

en: selects machines to execute against from inventory
ja: インベントリーから実行するマシンを選択する

en: connects to those machines (or network devices, or other managed nodes), usually over SSH
ja: 通常は SSH 経由で、このマシン (もしくはネットワークデバイスまたはその他の管理対象ノード) に接続する

en: copies one or more modules to the remote machines and starts execution there
ja: 1 つ以上のモジュールをリモートマシンにコピーし、そこで実行を開始する

en: Ansible can do much more, but you should understand the most common use case before exploring all the powerful configuration, deployment, and orchestration features of Ansible. This page illustrates the basic process with a simple inventory and an ad hoc command. Once you understand how Ansible works, you can read more details about :ref:`ad hoc commands<intro_adhoc>`, organize your infrastructure with :ref:`inventory<intro_inventory>`, and harness the full power of Ansible with :ref:`playbooks<playbooks_intro>`.
ja: Ansible はさらに多くのことができますが、Ansible の強力な設定、デプロイメント、オーケストレーション機能をすべて試す前に、最も一般的な使用例を理解しておく必要があります。このページでは、簡単なインベントリーとアドホックコマンドを使用して、基本的なプロセスを説明しています。Ansible の仕組みを理解したら、:ref:`ad hoc commands<intro_adhoc>` の詳細を読み、:ref:`inventory<intro_inventory>` でインフラストラクチャーを整理し、:ref:`playbooks<playbooks_intro>` で Ansible の機能を最大限に活用することができます。

en: Selecting machines from inventory
ja: インベントリーからのマシンの選択

en: Ansible reads information about which machines you want to manage from your inventory. Although you can pass an IP address to an ad hoc command, you need inventory to take advantage of the full flexibility and repeatability of Ansible.
ja: Ansible は、インベントリーから管理したいマシンの情報を読み込みます。アドホックコマンドに IP アドレスを渡すこともできますが、Ansible の柔軟性と再現性を最大限に活用するにはインベントリーが必要です。

en: Action: create a basic inventory
ja: アクション: 基本的なインベントリーの作成

en: For this basic inventory, edit (or create) ``/usr/local/etc/ansible/hosts`` and add a few remote systems to it. For this example, use either IP addresses or FQDNs:
ja: この基本的なインベントリーでは、``/usr/local/etc/ansible/hosts`` を編集 (または作成) し、リモートシステムをいくつか追加します。たとえば、IP アドレスまたは FQDN を使用します。

en: Beyond the basics
ja: 中級編

en: Your inventory can store much more than IPs and FQDNs. You can create :ref:`aliases<inventory_aliases>`, set variable values for a single host with :ref:`host vars<host_variables>`, or set variable values for multiple hosts with :ref:`group vars<group_variables>`.
ja: インベントリーには、IP や FQDN 以外にも多くの情報を保存することができます。:ref:`エイリアス<inventory_aliases>` を作成したり、:ref:`host 変数<host_variables>` で単一のホストに変数値を設定したり、:ref:`group 変数<group_variables>` で複数のホストに変数値を設定したりすることができます。

en: Connecting to remote nodes
ja: リモートノードへの接続

en: Ansible communicates with remote machines over the `SSH protocol <https://www.ssh.com/ssh/protocol/>`_. By default, Ansible uses native OpenSSH and connects to remote machines using your current user name, just as SSH does.
ja: Ansible は `SSH プロトコル <https://www.ssh.com/ssh/protocol/>`_ でリモートマシンと通信します。デフォルトでは、Ansible はネイティブの OpenSSH を使用し、SSH と同様に現在のユーザー名を使用してリモートマシンに接続します。

en: Action: check your SSH connections
ja: アクション: SSH 接続の確認

en: Confirm that you can connect using SSH to all the nodes in your inventory using the same username. If necessary, add your public SSH key to the ``authorized_keys`` file on those systems.
ja: インベントリー内のすべてのノードに、同じユーザー名で SSH 接続できることを確認します。必要に応じて、これらのシステムの ``authorized_keys`` ファイルに自分の公開 SSH 鍵を追加します。

en: You can override the default remote user name in several ways, including:
ja: 次のようないくつかの方法で、デフォルトのリモートユーザー名を上書きできます。

en: passing the ``-u`` parameter at the command line
ja: コマンドラインで ``-u`` パラメーターを渡す

en: setting user information in your inventory file
ja: インベントリーファイルにユーザー情報を設定する

en: setting user information in your configuration file
ja: 設定ファイルにユーザー情報を設定する

en: setting environment variables
ja: 追加の環境変数を設定する

en: See :ref:`general_precedence_rules` for details on the (sometimes unintuitive) precedence of each method of passing user information. You can read more about connections in :ref:`connections`.
ja: ユーザー情報を渡す各メソッドの優先順位 (意図しない場合もあります) の詳細は、「:ref:`general_precedence_rules`」を参照してください。接続については、「:ref:`connections`」を参照してください。

en: Copying and executing modules
ja: モジュールのコピーおよび実行

en: Once it has connected, Ansible transfers the modules required by your command or playbook to the remote machine(s) for execution.
ja: 接続後、Ansible はコマンドまたは Playbook が必要とするモジュールをリモートマシンに転送して実行します。

en: Action: run your first Ansible commands
ja: アクション: 最初の Ansible コマンドの実行

en: Use the ping module to ping all the nodes in your inventory:
ja: ping モジュールを使用して、インベントリー内のすべてのノードに対して ping を実行します。

en: You should see output for each host in your inventory, similar to this:
ja: 次のようなインベントリー内の各ホストの出力が表示されます。

en: You can use ``-u`` as one way to specify the user to connect as, by default Ansible uses SSH, which defaults to the 'current user'.
ja: ``-u`` は、接続するユーザーを指定する 1 つの方法として使用できます。デフォルトでは、Ansible は SSH を使用しますが、SSH ではデフォルトで「現在のユーザー」が指定されます。

en: Now run a live command on all of your nodes:
ja: 全ノードでライブコマンドを実行します。

en: Action: Run your first playbook
ja: アクション: 最初の Playbook の実行

en: Playbooks are used to pull together tasks into reusable units.
ja: Playbook は、複数のタスクを再利用可能な単位にプルするために使用されます。

en: Ansible does not store playbooks for you; they are simply YAML documents that you store and manage, passing them to Ansible to run as needed.
ja: Ansible は、Playbook を保存しません。Playbook は、保存および管理する単純な YAML ドキュメントであり、必要に応じて実行するために Ansible に渡します。

en: In a directory of your choice you can create your first playbook in a file called mytask.yml:
ja: 任意のディレクトリーでは、mytask.yml という名前のファイルに最初の Playbook を作成できます。

en: You can run this command as follows:
ja: このコマンドは、以下のように実行できます。

en: and may see output like this:
ja: また、以下のような出力が表示される可能性があります。

en: Read on to learn more about controlling which nodes your playbooks execute on, more sophisticated tasks, and the meaning of the output.
ja: Playbook が実行するノード、より高度なタスク、および出力の意味を把握するには、こちらを参照してください。

en: By default Ansible uses SFTP to transfer files. If the machine or device you want to manage does not support SFTP, you can switch to SCP mode in :ref:`intro_configuration`. The files are placed in a temporary directory and executed from there.
ja: Ansible のデフォルトでは、ファイルの転送に SFTP を使用します。管理するマシンやデバイスが SFTP をサポートしていない場合は、:ref:`intro_configuration` で SCP モードに切り替えることができます。ファイルは一時ディレクトリーに置かれ、そこから実行されます。

en: If you need privilege escalation (sudo and similar) to run a command, pass the ``become`` flags:
ja: コマンドを実行する権限昇格 (sudo など) が必要な場合は、``become`` フラグを渡します。

en: You can read more about privilege escalation in :ref:`become`.
ja: 権限の昇格の詳細は、「:ref:`become`」を参照してください。

en: Congratulations! You have contacted your nodes using Ansible. You used a basic inventory file and an ad hoc command to direct Ansible to connect to specific remote nodes, copy a module file there and execute it, and return output. You have a fully working infrastructure.
ja: これで、Ansible を使用してノードに接続できました。基本的なインベントリーファイルとアドホックコマンドを使用して、Ansible が特定のリモートノードに接続し、そこにモジュールファイルをコピーして実行し、出力を返すように指示しました。これで完全に機能するインフラストラクチャーが完成しました。

en: Resources
ja: リソース

en: Next steps
ja: 次のステップ

en: Next you can read about more real-world cases in :ref:`intro_adhoc`, explore what you can do with different modules, or read about the Ansible :ref:`working_with_playbooks` language.  Ansible is not just about running commands, it also has powerful configuration management and deployment features.
ja: 次に、:ref:`intro_adhoc` のより多くの実例を読んだり、さまざまなモジュールでできることを調べたり、Ansible :ref:`working_with_playbooks` の言語について読んだりすることができます。Ansible は、単にコマンドを実行するだけでなく、強力な構成管理機能およびデプロイ機能を備えています。

en: More information about inventory
ja: インベントリーの詳細情報

en: Learning Ansible's configuration management language
ja: Ansible の設定管理言語の概要

en: Demonstrations of different Ansible usecases
ja: 各種 Ansible のユースケースのデモ

en: Labs to provide further knowledge on different topics
ja: さまざまなトピックでの詳細な知識を提供するラボ

en: How to build your inventory
ja: インベントリーの構築方法

en: Ansible works against multiple managed nodes or "hosts" in your infrastructure at the same time, using a list or group of lists known as inventory. Once your inventory is defined, you use :ref:`patterns <intro_patterns>` to select the hosts or groups you want Ansible to run against.
ja: Ansible は、インベントリーと呼ばれるリスト、またはリストのグループを使用して、インフラストラクチャーにある複数の管理ノードまたは「ホスト」に対して同時に機能します。インベントリーが定義されたら、:ref:`パターン <intro_patterns>` を使用して Ansible で実行するホストまたはグループを選択します。

en: The default location for inventory is a file called ``/usr/local/etc/ansible/hosts``. You can specify a different inventory file at the command line using the ``-i <path>`` option. You can also use multiple inventory files at the same time as described in :ref:`using_multiple_inventory_sources`, and/or pull inventory from dynamic or cloud sources or different formats (YAML, ini, and so on), as described in :ref:`intro_dynamic_inventory`. Introduced in version 2.4, Ansible has :ref:`inventory_plugins` to make this flexible and customizable.
ja: インベントリーのデフォルトの場所は、``/usr/local/etc/ansible/hosts`` と呼ばれるファイルです。``-i <path>`` オプションを使用して、コマンドラインで別のインベントリーファイルを指定できます。「:ref:`intro_dynamic_inventory`」で説明されているように、:ref:`using_multiple_inventory_sources` で説明されている複数のインベントリーファイルを同時に使用したり、動的またはクラウドソースまたは異なる形式 (YAML、ini など) からインベントリーをプルしたりすることもできます。バージョン 2.4 で導入された Ansible には、この柔軟でカスタマイズ可能な :ref:`inventory_plugins` があります。

en: Inventory basics: formats, hosts, and groups
ja: インベントリーの基本: 形式、ホスト、およびグループ

en: The inventory file can be in one of many formats, depending on the inventory plugins you have. The most common formats are INI and YAML. A basic INI ``/usr/local/etc/ansible/hosts`` might look like this:
ja: インベントリーファイルは、所有するインベントリープラグインに応じて、多くの形式のいずれかになります。最も一般的な形式は INI および YAML です。基本的な INI ``/usr/local/etc/ansible/hosts`` は以下のようになります。

en: The headings in brackets are group names, which are used in classifying hosts and deciding what hosts you are controlling at what times and for what purpose. Group names should follow the same guidelines as :ref:`valid_variable_names`.
ja: 括弧内の見出しはグループ名で、ホストを分類し、どの時点で、どのような目的で、どのホストを制御するかを決定するのに使用されます。グループ名は、:ref:`valid_variable_names` と同じガイドラインに従ってください。

en: Here's that same basic inventory file in YAML format:
ja: 以下は、同じ基本的なインベントリーファイルの YAML 形式です。

en: Default groups
ja: デフォルトのグループ

en: There are two default groups: ``all`` and ``ungrouped``. The ``all`` group contains every host. The ``ungrouped`` group contains all hosts that don't have another group aside from ``all``. Every host will always belong to at least 2 groups (``all`` and ``ungrouped`` or ``all`` and some other group). Though ``all`` and ``ungrouped`` are always present, they can be implicit and not appear in group listings like ``group_names``.
ja: デフォルトグループが 2 つ (``all`` および ``ungrouped``) あります。``all`` グループには、すべてのホストが含まれています。``ungrouped`` グループは、``all`` 以外のグループを持たないすべてのホストを含みます。すべてのホストは、常に少なくとも 2 つのグループ (``all`` と ``ungrouped``、または``all`` と他のグループ) に属しています。``all`` と ``ungrouped`` は常に存在していますが、``group_names`` のようにグループ一覧に表示されない暗黙的なものもあります。

en: Hosts in multiple groups
ja: 複数グループ内のホスト

en: You can (and probably will) put each host in more than one group. For example a production webserver in a datacenter in Atlanta might be included in groups called [prod] and [atlanta] and [webservers]. You can create groups that track:
ja: 各ホストを複数のグループに配置できます。たとえば、Atlanta のデータセンターの実稼働 Web サーバーは、[prod]、[atlanta]、および [webservers] と呼ばれるグループに追加できます。以下を追跡するグループを作成できます。

en: What - An application, stack or microservice (for example, database servers, web servers, and so on).
ja: なにを - アプリケーション、スタック、またはマイクロサービス (たとえば、データベースサーバー、Web サーバーなど)。

en: Where - A datacenter or region, to talk to local DNS, storage, and so on (for example, east, west).
ja: どこで - データセンターまたはリージョンで、ローカルの DNS やストレージなどと通信します (例: east、west)。

en: When - The development stage, to avoid testing on production resources (for example, prod, test).
ja: いつ - 開発段階で、実稼働リソースでのテストを回避するため (例: prod、test)。

en: Extending the previous YAML inventory to include what, when, and where would look like:
ja: 以前の YAML インベントリーを拡張して、上述の「いつ、どこで、なにを」が含まれるようにします。

en: You can see that ``one.example.com`` exists in the ``dbservers``, ``east``, and ``prod`` groups.
ja: ``one.example.com`` が ``dbservers``、``east``、および ``prod`` グループに存在することを確認できます。

en: You can also use nested groups to simplify ``prod`` and ``test`` in this inventory, for the same result:
ja: また、入れ子になったグループを使用して、このインベントリーで ``prod`` と``test`` を簡素化しても、同じ結果になります。

en: You can find more examples on how to organize your inventories and group your hosts in :ref:`inventory_setup_examples`.
ja: インベントリーを整理し、ホストをグループ化する方法は、「:ref:`inventory_setup_examples`」を参照してください。

en: Adding ranges of hosts
ja: ホスト範囲の追加

en: If you have a lot of hosts with a similar pattern, you can add them as a range rather than listing each hostname separately:
ja: 同様のパターンを持つホストが多数ある場合は、各ホスト名を個別に一覧表示するのではなく、ホストを範囲として追加できます。

en: In INI:
ja: INI の場合は、以下のようになります。

en: In YAML:
ja: YAML の場合は、以下のようになります。

en: You can specify a stride (increments between sequence numbers) when defining a numeric range of hosts:
ja: ホストの数値範囲を定義する際に、stride (シーケンス番号間の増分) を指定することができます。

en: For numeric patterns, leading zeros can be included or removed, as desired. Ranges are inclusive. You can also define alphabetic ranges:
ja: 数値のパターンでは、必要に応じて先頭にゼロを含めるか、または削除できます。範囲は包含的範囲も定義できます。また、アルファベットの範囲も定義できます。

en: Adding variables to inventory
ja: インベントリーへの変数の追加

en: You can store variable values that relate to a specific host or group in inventory. To start with, you may add variables directly to the hosts and groups in your main inventory file. As you add more and more managed nodes to your Ansible inventory, however, you will likely want to store variables in separate host and group variable files. See :ref:`define_variables_in_inventory` for details.
ja: インベントリー内の特定のホストやグループに関連する変数値を保存することができます。最初のうちは、メインのインベントリーファイルのホストやグループに直接変数を追加することができます。しかし、Ansible インベントリーに管理ノードをどんどん追加していくと、変数をホストやグループの変数ファイルに分けて保存したくなることがあります。詳細は「:ref:`define_variables_in_inventory`」を参照してください。

en: Assigning a variable to one machine: host variables
ja: あるマシンへの変数の割り当て: ホスト変数

en: You can easily assign a variable to a single host, then use it later in playbooks. In INI:
ja: 1 台のホストに変数を簡単に割り当てると、後で Playbook で使用できます。INI では、以下のようになります。

en: Unique values like non-standard SSH ports work well as host variables. You can add them to your Ansible inventory by adding the port number after the hostname with a colon:
ja: 非標準の SSH ポートのような一意な値は、ホスト変数としてうまく機能します。ホスト名の後にコロンを付けてポート番号を追加することで、Ansible インベントリーに追加することができます。

en: Connection variables also work well as host variables:
ja: 接続変数もホスト変数として機能します。

en: If you list non-standard SSH ports in your SSH config file, the ``openssh`` connection will find and use them, but the ``paramiko`` connection will not.
ja: SSH 設定ファイル内に非標準の SSH ポートの一覧を表示した場合、``openssh`` 接続はそのポートを見つけて使用しますが、``paramiko`` 接続は行われません。

en: Inventory aliases
ja: インベントリーエイリアス

en: You can also define aliases in your inventory:
ja: エイリアスをインベントリーに定義することもできます。

en: In the above example, running Ansible against the host alias "jumper" will connect to 192.0.2.50 on port 5555. See :ref:`behavioral inventory parameters <behavioral_parameters>` to further customize the connection to hosts.
ja: 上記の例では、ホストの別名「jumper」に対して Ansible を実行すると、ポート 5555 の 192.0.2.50 に接続されます。ホストへの接続をさらにカスタマイズするには、「:ref:`動作用のインベントリーパラメーター <behavioral_parameters>`」を参照してください。

en: Values passed in the INI format using the ``key=value`` syntax are interpreted differently depending on where they are declared:
ja: ``key=value`` 構文を使用して INI 形式で渡される値が解釈される方法は、宣言される場所に応じて異なります。

en: When declared inline with the host, INI values are interpreted as Python literal structures           (strings, numbers, tuples, lists, dicts, booleans, None). Host lines accept multiple ``key=value`` parameters per line. Therefore they need a way to indicate that a space is part of a value rather than a separator.
ja: ホストのインラインで宣言すると、INI 値は Pythonの リテラル構造 (文字列、数値、タプル、リスト、ディクショナリー、ブール値、なし) として解釈されます。ホストの行は、1 行につき複数の ``key=value`` パラメーターを受け付けます。そのため、スペースが区切り文字ではなく値の一部であることを示す方法が必要です。

en: When declared in a ``:vars`` section, INI values are interpreted as strings. For example ``var=FALSE`` would create a string equal to 'FALSE'. Unlike host lines, ``:vars`` sections accept only a single entry per line, so everything after the ``=`` must be the value for the entry.
ja: ``:vars`` セクションで宣言すると、INI の値は文字列として解釈されます。たとえば、``var=FALSE`` は FALSE と等しい文字列を作成します。ホスト行とは異なり、``:vars`` セクションは行ごとに 1 つのエントリーのみを許可するため、``=`` の後に続くすべてのものがエントリーの値である必要があります。

en: If a variable value set in an INI inventory must be a certain type (for example, a string or a boolean value), always specify the type with a filter in your task. Do not rely on types set in INI inventories when consuming variables.
ja: INI インベントリーに設定されている変数の値が特定の型 (文字列やブール値など) でなければならない場合は、必ずタスクのフィルターで型を指定してください。変数を使用する際に、INI インベントリーに設定されている型に頼らないでください。

en: Consider using YAML format for inventory sources to avoid confusion on the actual type of a variable. The YAML inventory plugin processes variable values consistently and correctly.
ja: 変数の実際のタイプに関する混乱を回避するために、インベントリーソースに YAML 形式を使用することを検討してください。YAML インベントリープラグインは変数の値を一貫して、正しく処理します。

en: Generally speaking, this is not the best way to define variables that describe your system policy. Setting variables in the main inventory file is only a shorthand. See :ref:`splitting_out_vars` for guidelines on storing variable values in individual files in the 'host_vars' directory.
ja: 一般的には、システムポリシーを記述する変数を定義するのに、この方法は最適ではありません。メインのインベントリーファイルに変数を設定することは、単なる省略にすぎません。変数の値を「host_vars」ディレクトリー内の個々のファイルに保存する際のガイドラインについては、「:ref:`splitting_out_vars`」を参照してください。

en: Assigning a variable to many machines: group variables
ja: 多くのマシンへの変数の割り当て: グループ変数

en: If all hosts in a group share a variable value, you can apply that variable to an entire group at once. In INI:
ja: グループ内のすべてのホストが変数の値を共有している場合は、その変数をグループ全体に一度に適用することができます。INI の場合は以下のようになります。

en: Group variables are a convenient way to apply variables to multiple hosts at once. Before executing, however, Ansible always flattens variables, including inventory variables, to the host level. If a host is a member of multiple groups, Ansible reads variable values from all of those groups. If you assign different values to the same variable in different groups, Ansible chooses which value to use based on internal :ref:`rules for merging <how_we_merge>`.
ja: グループ変数は、複数のホストに一度に変数を適用する便利な方法です。しかし、Ansible は実行前に、インベントリー変数を含む変数を常にホストレベルにフラット化します。ホストが複数のグループに属している場合、Ansible はそれらのグループのすべてから変数の値を読み取ります。異なるグループで同じ変数に異なる値を割り当てた場合、Ansible は内部 :ref:`マージのルール <how_we_merge>` に基づいてどの値を使用するかを選択します。

en: Inheriting variable values: group variables for groups of groups
ja: 変数値の継承: グループのグループ用グループ変数

en: You can make groups of groups using the ``:children`` suffix in INI or the ``children:`` entry in YAML. You can apply variables to these groups of groups using ``:vars`` or ``vars:``:
ja: INI の ``:children`` サフィックスまたは YAML の ``children:`` エントリーを使用して、グループのグループを作成できます。``:vars`` または ``vars:`` を使用して、変数をそれらのグループのグループに適用できます。

en: If you need to store lists or hash data, or prefer to keep host and group specific variables separate from the inventory file, see :ref:`splitting_out_vars`.
ja: リストまたはハッシュデータを保存する必要がある場合や、インベントリーファイルとは別にホストおよびグループ固有の変数を保持する必要がある場合は、「:ref:`splitting_out_vars`」を参照してください。

en: Child groups have a couple of properties to note:
ja: 子グループには、注意すべき以下のプロパティーがあります。

en: Any host that is member of a child group is automatically a member of the parent group.
ja: 子グループのメンバーであるホストは、自動的に親グループのメンバーになります。

en: A child group's variables will have higher precedence (override) a parent group's variables.
ja: 子グループの変数は、親グループの変数よりも優先度が高くなります (上書きされます)。

en: Groups can have multiple parents and children, but not circular relationships.
ja: グループに複数の親と子を追加することはできますが、循環関係は設定できません。

en: Hosts can also be in multiple groups, but there will only be **one** instance of a host, merging the data from the multiple groups.
ja: ホストは複数のグループに属することもできますが、ホストのインスタンスは **1 つ** だけであり、複数のグループからのデータをマージします。

en: Organizing host and group variables
ja: ホスト変数とグループ変数の整理

en: Although you can store variables in the main inventory file, storing separate host and group variables files may help you organize your variable values more easily. Host and group variable files must use YAML syntax. Valid file extensions include '.yml', '.yaml', '.json', or no file extension. See :ref:`yaml_syntax` if you are new to YAML.
ja: メインのインベントリーファイルに変数を格納できますが、ホスト変数ファイルとグループ変数ファイルを別々に格納することで、変数の値をより簡単に整理できる場合があります。ホストとグループの変数ファイルは、YAML 構文を使用する必要があります。有効なファイル拡張子は、「.yml」、「.yaml」、または「.json」です。ファイル拡張子を付けなくても有効です。YAML を初めて使用する場合は、「:ref:`yaml_syntax`」を参照してください。

en: Ansible loads host and group variable files by searching paths relative to the inventory file or the playbook file. If your inventory file at ``/usr/local/etc/ansible/hosts`` contains a host named 'foosball' that belongs to two groups, 'raleigh' and 'webservers', that host will use variables in YAML files at the following locations:
ja: Ansible は、インベントリーファイルまたは Playbook ファイルからの相対パスを検索して、ホストおよびグループ変数ファイルを読み込みます。``/usr/local/etc/ansible/hosts`` のインベントリーファイルに「foosball」という名前のホストがあり、それが「raleigh」と「webservers」という 2 つのグループに所属している場合、そのホストは以下の場所にある YAML ファイルの変数を使用します。

en: For example, if you group hosts in your inventory by datacenter, and each datacenter uses its own NTP server and database server, you can create a file called ``/usr/local/etc/ansible/group_vars/raleigh`` to store the variables for the ``raleigh`` group:
ja: たとえば、インベントリー内のホストをデータセンターごとにまとめ、各データセンターが独自の NTP サーバーおよびデータベースサーバーを使用する場合は、``/usr/local/etc/ansible/group_vars/raleigh`` という名前のファイルを作成して、``raleigh`` グループの変数を保存できます。

en: You can also create *directories* named after your groups or hosts. Ansible will read all the files in these directories in lexicographical order. An example with the 'raleigh' group:
ja: また、グループまたはホストの名前が付けられた *ディレクトリー* も作成できます。Ansible は、これらのディレクトリーに含まれるすべてのファイルを辞書の順に読み込みます。例では、「raleigh」グループを使用しています。

en: All hosts in the 'raleigh' group will have the variables defined in these files available to them. This can be very useful to keep your variables organized when a single file gets too big, or when you want to use :ref:`Ansible Vault<playbooks_vault>` on some group variables.
ja: 「raleigh」グループのすべてのホストは、これらのファイルで定義された変数を利用できるようになります。これは、1 つのファイルが大きくなりすぎたときに、変数を整理しておくのに非常に便利です。また、いくつかのグループ変数に :ref:`Ansible Vault<playbooks_vault>` を使用したい場合にも便利です。

en: You can also add ``group_vars/`` and ``host_vars/`` directories to your playbook directory. The ``ansible-playbook`` command looks for these directories in the current working directory by default. Other Ansible commands (for example, ``ansible``, ``ansible-console``, and so on) will only look for ``group_vars/`` and ``host_vars/`` in the inventory directory. If you want other commands to load group and host variables from a playbook directory, you must provide the ``--playbook-dir`` option on the command line. If you load inventory files from both the playbook directory and the inventory directory, variables in the playbook directory will override variables set in the inventory directory.
ja: また、ディレクトリー ``group_vars/`` および ``host_vars/`` を Playbook ディレクトリーに追加することもできます。``ansible-playbook`` コマンドは、デフォルトでは、これらのディレクトリーを現在の作業ディレクトリーで探します。他の Ansible コマンド (たとえば、``ansible``、``ansible-console`` など) は、インベントリーディレクトリー内の ``group_vars/`` と``host_vars/`` のみを探します。他のコマンドで Playbook ディレクトリーからグループ変数やホスト変数を読み込む場合は、コマンドラインで ``--playbook-dir`` オプションを指定する必要があります。Playbook ディレクトリーと inventory ディレクトリーの両方からインベントリーファイルを読み込んだ場合、Playbook ディレクトリーの変数はインベントリーディレクトリーで設定された変数よりも優先されます。

en: Keeping your inventory file and variables in a git repo (or other version control) is an excellent way to track changes to your inventory and host variables.
ja: git リポジトリー (または他のバージョン管理) でインベントリーファイルおよび変数を維持することは、インベントリーおよびホスト変数への変更を追跡する優れた方法です。

en: How variables are merged
ja: 変数をマージする方法

en: By default variables are merged/flattened to the specific host before a play is run. This keeps Ansible focused on the Host and Task, so groups don't really survive outside of inventory and host matching. By default, Ansible overwrites variables including the ones defined for a group and/or host (see :ref:`DEFAULT_HASH_BEHAVIOUR<DEFAULT_HASH_BEHAVIOUR>`). The order/precedence is (from lowest to highest):
ja: デフォルトでは、プレイが実行される前に、変数が特定のホストにマージ/フラット化されます。これにより、Ansible はホストとタスクに焦点を当てているため、グループはインベントリーとホストの一致以外では実際には存続しません。デフォルトでは、Ansible はグループやホストに定義されたものを含む変数を上書きします (:ref:`DEFAULT_HASH_BEHAVIOUR<DEFAULT_HASH_BEHAVIOUR>` 参照)。その順序/優先順位は (低いものから高いものへ) となっています。

en: all group (because it is the 'parent' of all other groups)
ja: すべてのグループ (他のすべてのグループの「親」であるため)

en: parent group
ja: 親グループ

en: child group
ja: 子グループ

en: host
ja: ホスト

en: By default Ansible merges groups at the same parent/child level in ASCII order, and the last group loaded overwrites the previous groups. For example, an a_group will be merged with b_group and b_group vars that match will overwrite the ones in a_group.
ja: デフォルトでは、Ansible は同じ親子レベルのグループを ASCII 順にマージし、最後に読み込まれたグループがそれ以前のグループを上書きします。たとえば、a_group は b_group にマージされ、一致する b_group の変数が a_group の変数を上書きします。

en: You can change this behavior by setting the group variable ``ansible_group_priority`` to change the merge order for groups of the same level (after the parent/child order is resolved). The larger the number, the later it will be merged, giving it higher priority. This variable defaults to ``1`` if not set. For example:
ja: この動作を変更するには、グループ変数 ``ansible_group_priority`` を設定して、同じレベルのグループのマージ順序を変更することができます (親子の順序が解決された後)。数字が大きいほど後にマージされ、優先順位が高くなります。この変数が設定されていない場合のデフォルトは ``1`` です。たとえば、以下のようになります。

en: In this example, if both groups have the same priority, the result would normally have been ``testvar == b``, but since we are giving the ``a_group`` a higher priority the result will be ``testvar == a``.
ja: この例では、両方のグループの優先順位が同じ場合、結果は通常 ``testvar == b`` になりますが、``a_group`` の優先度が高いため、結果は ``testvar == a`` になります。

en: ``ansible_group_priority`` can only be set in the inventory source and not in group_vars/, as the variable is used in the loading of group_vars.
ja: ``ansible_group_priority`` は、group_vars の読み込みでこの変数が使用されるため、インベントリーソースでのみ設定でき、group_vars/ では設定できません。

en: Using multiple inventory sources
ja: 複数のインベントリーソースの使用

en: You can target multiple inventory sources (directories, dynamic inventory scripts or files supported by inventory plugins) at the same time by giving multiple inventory parameters from the command line or by configuring :envvar:`ANSIBLE_INVENTORY`. This can be useful when you want to target normally separate environments, like staging and production, at the same time for a specific action.
ja: コマンドラインから複数のインベントリーパラメーターを指定するか、:envvar:`ANSIBLE_INVENTORY` を設定することで、複数のインベントリーリソース (ディレクトリー、動的インベントリースクリプト、またはインベントリープラグインによりサポートされるファイル) を同時に対象に指定できます。これは、ステージ環境や実稼働環境など、通常は異なる環境を同時に対象に指定にして特定のアクションを実行したい場合に便利です。

en: Target two sources from the command line like this:
ja: 以下のようなコマンドラインから 2 つのソースを対象とします。

en: Keep in mind that if there are variable conflicts in the inventories, they are resolved according to the rules described in :ref:`how_we_merge` and :ref:`ansible_variable_precedence`. The merging order is controlled by the order of the inventory source parameters. If ``[all:vars]`` in staging inventory defines ``myvar = 1``, but production inventory defines ``myvar = 2``, the playbook will be run with ``myvar = 2``. The result would be reversed if the playbook was run with ``-i production -i staging``.
ja: インベントリーに変数の競合がある場合は、:ref:`how_we_merge` および :ref:`ansible_variable_precedence` で説明されているルールに従って解決されることを覚えておいてください。マージの順序は、インベントリーのソースパラメーターの順序によって制御されます。ステージングインベントリーの ``[all:vars]`` が ``myvar = 1`` を定義していて、実稼働インベントリーが ``myvar = 2`` を定義している場合、Playbook は ``myvar = 2`` で実行されます。Playbook が ``-i production -i staging`` で実行された場合は、結果が逆になります。

en: **Aggregating inventory sources with a directory**
ja: **インベントリーソースをディレクトリーに集約**

en: You can also create an inventory by combining multiple inventory sources and source types under a directory. This can be useful for combining static and dynamic hosts and managing them as one inventory. The following inventory combines an inventory plugin source, a dynamic inventory script, and a file with static hosts:
ja: また、複数のインベントリーソースやソースタイプを 1 つのディレクトリー下にまとめてインベントリーを作成することもできます。これは、静的ホストと動的ホストを組み合わせて、1 つのインベントリーとして管理するのに便利です。次のインベントリーは、インベントリープラグインソース、動的インベントリースクリプト、および静的ホストのファイルを組み合わせたものです。

en: You can target this inventory directory simply like this:
ja: このインベントリーディレクトリーは、次のように簡単に対象に設定できます。

en: It can be useful to control the merging order of the inventory sources if there's variable conflicts or group of groups dependencies to the other inventory sources. The inventories are merged in ASCII order according to the filenames so the result can be controlled by adding prefixes to the files:
ja: 他のインベントリーソースに対する変数の競合やグループのグループの依存関係がある場合は、インベントリーソースのマージ順序を制御すると便利です。インベントリーはファイル名に応じて ASCII 順にマージされるため、ファイルにプレフィックスを追加することで結果をコントロールすることができます。

en: If ``01-openstack.yml`` defines ``myvar = 1`` for the group ``all``, ``02-dynamic-inventory.py`` defines ``myvar = 2``, and ``03-static-inventory`` defines ``myvar = 3``, the playbook will be run with ``myvar = 3``.
ja: ``01-openstack.yml`` がグループ ``all`` に対して``myvar = 1`` を定義し、``02-dynamic-inventory.py`` が ``myvar = 2`` を定義し、``03-static-inventory`` が``myvar = 3`` を定義した場合は、Playbook が ``myvar = 3`` で実行します。

en: For more details on inventory plugins and dynamic inventory scripts see :ref:`inventory_plugins` and :ref:`intro_dynamic_inventory`.
ja: インベントリープラグインおよび動的インベントリースクリプトの詳細は、「:ref:`inventory_plugins`」および「:ref:`intro_dynamic_inventory`」を参照してください。

en: Connecting to hosts: behavioral inventory parameters
ja: ホストへの接続: 動作用インベントリーパラメーター

en: As described above, setting the following variables control how Ansible interacts with remote hosts.
ja: 上記のように、以下の変数を設定して、Ansible がリモートホストと対話する方法を制御します。

en: Host connection:
ja: ホスト接続:

en: Connection type to the host. This can be the name of any of ansible's connection plugins. SSH protocol types are ``smart``, ``ssh`` or ``paramiko``.  The default is smart. Non-SSH based types are described in the next section.
ja: ホストへの接続タイプ。これは、Ansible の接続プラグインの名前です。SSH プロトコルタイプは ``smart``、``ssh``、または ``paramiko`` です。デフォルトは smart です。SSH ベース以外のタイプは次のセクションで説明します。

en: General for all connections:
ja: すべての接続に対する一般的な設定:

en: The name of the host to connect to, if different from the alias you wish to give to it.
ja: 接続するホストの名前 (付与するエイリアスと異なる場合)。

en: The connection port number, if not the default (22 for ssh)
ja: デフォルトではない場合は、接続ポート番号 (ssh の場合は 22)

en: The user name to use when connecting to the host
ja: ホストに接続する際に使用するユーザー名

en: The password to use to authenticate to the host (never store this variable in plain text; always use a vault. See :ref:`tip_for_variables_and_vaults`)
ja: ホストへの認証に使用するパスワード (この変数を平文で保存しないでください。常に Valut を使用してください。:ref:`tip_for_variables_and_vaults` を参照)。

en: Specific to the SSH connection:
ja: SSH 接続に固有:

en: Private key file used by ssh.  Useful if using multiple keys and you don't want to use SSH agent.
ja: ssh が使用する秘密鍵ファイル。複数の鍵を使用し、SSH エージェントを使用したくない場合に便利です。

en: This setting is always appended to the default command line for :command:`sftp`, :command:`scp`, and :command:`ssh`. Useful to configure a ``ProxyCommand`` for a certain host (or group).
ja: この設定は、常に :command:`sftp`、:command:`scp`、および :command:`ssh` のデフォルトのコマンドラインに追加されます。特定のホスト (またはグループ) に ``ProxyCommand`` を設定してください。

en: This setting is always appended to the default :command:`sftp` command line.
ja: この設定は、デフォルトの :command:`sftp` コマンドラインに常に付加されます。

en: This setting is always appended to the default :command:`scp` command line.
ja: この設定は、デフォルトの :command:`scp` コマンドラインに常に付加されます。

en: This setting is always appended to the default :command:`ssh` command line.
ja: この設定は、デフォルトの :command:`ssh` コマンドラインに常に付加されます。

en: Determines whether or not to use SSH pipelining. This can override the ``pipelining`` setting in :file:`ansible.cfg`.
ja: SSH パイプラインを使用するかどうかを決定します。これは :file:`ansible.cfg` の ``pipelining`` の設定を上書きすることができます。

en: ansible_ssh_executable (added in version 2.2)
ja: ansible_ssh_executable (バージョン 2.2 で追加)

en: This setting overrides the default behavior to use the system :command:`ssh`. This can override the ``ssh_executable`` setting in :file:`ansible.cfg`.
ja: この設定により、システムの :command:`ssh` を使用するようにデフォルトの動作が上書きされます。これにより、:file:`ansible.cfg` の ``ssh_executable`` 設定を上書きできます。

en: Privilege escalation (see :ref:`Ansible Privilege Escalation<become>` for further details):
ja: 権限の昇格 (詳細は「:ref:`Ansible 権限昇格<become>`」を参照):

en: Equivalent to ``ansible_sudo`` or ``ansible_su``, allows to force privilege escalation
ja: ``ansible_sudo`` または ``ansible_su`` と同等です。これにより、権限昇格を強制できます。

en: Allows to set privilege escalation method
ja: 権限昇格メソッドの設定を許可します。

en: Equivalent to ``ansible_sudo_user`` or ``ansible_su_user``, allows to set the user you become through privilege escalation
ja: ``ansible_sudo_user`` または ``ansible_su_user`` と同等で、権限昇格により become を行うユーザーを設定できます。

en: Equivalent to ``ansible_sudo_password`` or ``ansible_su_password``, allows you to set the privilege escalation password (never store this variable in plain text; always use a vault. See :ref:`tip_for_variables_and_vaults`)
ja: ``ansible_sudo_password`` または ``ansible_su_password`` と同等で、特権昇格パスワードを設定できます (この変数を平文で保存せず、常に vault を使用してください。「:ref:`tip_for_variables_and_vaults`」を参照してください)。

en: Equivalent to ``ansible_sudo_exe`` or ``ansible_su_exe``, allows you to set the executable for the escalation method selected
ja: ``ansible_sudo_exe`` または ``ansible_su_exe`` と同等で、選択した昇格メソッドの実行ファイルを設定できます。

en: Equivalent to ``ansible_sudo_flags`` or ``ansible_su_flags``, allows you to set the flags passed to the selected escalation method. This can be also set globally in :file:`ansible.cfg` in the ``sudo_flags`` option
ja: ``ansible_sudo_flags`` または ``ansible_su_flags`` と同等で、選択された昇格方法に渡されるフラグを設定することができます。これは ``sudo_flags`` オプションの :file:`ansible.cfg` でもグローバルに設定できます。

en: Remote host environment parameters:
ja: リモートホスト環境パラメーター:

en: The shell type of the target system. You should not use this setting unless you have set the :ref:`ansible_shell_executable<ansible_shell_executable>` to a non-Bourne (sh) compatible shell.  By default commands are formatted using ``sh``-style syntax.  Setting this to ``csh`` or ``fish`` will cause commands executed on target systems to follow those shell's syntax instead.
ja: ターゲットシステムのシェルタイプ。:ref:`ansible_shell_executable<ansible_shell_executable>` を Bourne (sh) 以外の互換シェルに設定しない限り、この設定は使用しないでください。デフォルトでは、コマンドは ``sh`` スタイルの構文を使用してフォーマットされます。これを ``csh`` または ``fish`` に設定すると、ターゲットシステムで実行するコマンドがシェルの構文に従います。

en: The target host python path. This is useful for systems with more than one Python or not located at :command:`/usr/bin/python` such as \*BSD, or where :command:`/usr/bin/python` is not a 2.X series Python.  We do not use the :command:`/usr/bin/env` mechanism as that requires the remote user's path to be set right and also assumes the :program:`python` executable is named python, where the executable might be named something like :program:`python2.6`.
ja: ターゲットホストの Python パス。これは、複数の Python があるシステム、\*BSD などの :command:`/usr/bin/python` にないシステム、:command:`/usr/bin/python` が 2.X シリーズの Python 以外のシステムに役立ちます。リモートユーザーのパスを正しく設定する必要があり、:program:`python` 実行ファイルの名前が python であると想定するため、:command:`/usr/bin/env` メカニズムは使用しません。実行ファイルの名前は :program:`python2.6` のようになります。

en: Works for anything such as ruby or perl and works just like :ref:`ansible_python_interpreter<ansible_python_interpreter>`. This replaces shebang of modules which will run on that host.
ja: ruby や perl などのあらゆるもので動作し、:ref:`ansible_python_interpreter<ansible_python_interpreter>` のように機能します。これは、そのホストで実行されるモジュールのシバンに代わるものです。

en: This sets the shell the ansible controller will use on the target machine, overrides ``executable`` in :file:`ansible.cfg` which defaults to :command:`/bin/sh`.  You should really only change it if is not possible to use :command:`/bin/sh` (in other words, if :command:`/bin/sh` is not installed on the target machine or cannot be run from sudo.).
ja: これにより、Ansible コントローラーがターゲットマシンで使用するシェルを設定し、:file:`ansible.cfg` の ``executable`` を上書きします。デフォルトは :command:`/bin/sh` です。:command:`/bin/sh` を使用できない場合にのみ変更する必要があります (つまり、:command:`/bin/sh` がターゲットマシンにインストールされていない場合、または sudo から実行できない場合)。

en: Examples from an Ansible-INI host file:
ja: Ansible-INI ホストファイルの例:

en: Non-SSH connection types
ja: SSH 以外の接続タイプ

en: As stated in the previous section, Ansible executes playbooks over SSH but it is not limited to this connection type. With the host specific parameter ``ansible_connection=<connector>``, the connection type can be changed. The following non-SSH based connectors are available:
ja: 前のセクションで説明したように、Ansible は SSH で Playbook を実行しますが、この接続タイプは制限されていません。ホスト固有のパラメーター ``ansible_connection=<connector>`` では、接続タイプを変更できます。次の SSH 以外のコネクターを利用できます。

en: This connector can be used to deploy the playbook to the control machine itself.
ja: このコネクターは、Playbook をコントロールマシン自体にデプロイするために使用できます。

en: This connector deploys the playbook directly into Docker containers using the local Docker client. The following parameters are processed by this connector:
ja: このコネクターは、ローカルの Docker クライアントを使用して Playbook を直接 Docker コンテナーにデプロイします。以下のパラメーターはこのコネクターによって処理されます。

en: The name of the Docker container to connect to.
ja: 接続先の Docker コンテナーの名前。

en: The user name to operate within the container. The user must exist inside the container.
ja: コンテナー内で操作するためのユーザ名。ユーザーはコンテナー内に存在している必要があります。

en: If set to ``true`` the ``become_user`` will be used to operate within the container.
ja: ``true`` に設定すると、``become_user`` はコンテナー内で動作するために使用されます。

en: Could be a string with any additional arguments understood by Docker, which are not command specific. This parameter is mainly used to configure a remote Docker daemon to use.
ja: Docker が認識する追加の引数を持つ文字列を指定できますが、これはコマンド固有ではありません。このパラメーターは主に、使用するリモート Docker デーモンを設定するために使用されます。

en: Here is an example of how to instantly deploy to created containers:
ja: 以下は、作成されたコンテナーに即時にデプロイする例を示しています。

en: For a full list with available plugins and examples, see :ref:`connection_plugin_list`.
ja: 利用可能なプラグインとサンプルの一覧は、「:ref:`connection_plugin_list`」を参照してください。

en: If you're reading the docs from the beginning, this may be the first example you've seen of an Ansible playbook. This is not an inventory file. Playbooks will be covered in great detail later in the docs.
ja: ドキュメントを最初から読んでいる場合、これは Ansible Playbook を初めて確認した例です。これはインベントリーファイルではありません。Playbook は、ドキュメントで後ほど詳細に説明しています。

en: Inventory setup examples
ja: インベントリーの設定例

en: See also :ref:`sample_setup`, which shows inventory along with playbooks and other Ansible artifacts.
ja: Playbook およびその他の Ansible アーティファクトとともにインベントリーを表示する :ref:`sample_setup` も参照してください。

en: Example: One inventory per environment
ja: 例: 各環境に 1 つのインベントリー

en: If you need to manage multiple environments it's sometimes prudent to have only hosts of a single environment defined per inventory. This way, it is harder to, for instance, accidentally change the state of nodes inside the "test" environment when you actually wanted to update some "staging" servers.
ja: 複数の環境を管理する必要がある場合、インベントリーごとに 1 つの環境のホストのみを定義することが賢明な場合があります。こうすることで、たとえば、実際には「ステージング」サーバーを更新したいのに、誤って「テスト」環境内のノードの状態を変更してしまうことが起こりにくくなります。

en: For the example mentioned above you could have an :file:`inventory_test` file:
ja: 前述の例では、:file:`inventory_test` というファイルがあります。

en: That file only includes hosts that are part of the "test" environment. Define the "staging" machines in another file called :file:`inventory_staging`:
ja: このファイルには、「テスト」環境に含まれるホストのみが含まれます。:file:`inventory_staging` と呼ばれる別のファイルの「ステージング」マシンを定義します。

en: To apply a playbook called :file:`site.yml` to all the app servers in the test environment, use the following command::
ja: `site.yml` という名前の Playbook をテスト環境のすべてのアプリケーションサーバーに適用するには、次のコマンドを使用します。

en: Example: Group by function
ja: 例: 機能別にグループ化

en: In the previous section you already saw an example for using groups in order to cluster hosts that have the same function. This allows you, for instance, to define firewall rules inside a playbook or role affecting only database servers:
ja: 前セクションでは、同じ機能を持つホストをクラスター化するために、グループを使用する例をすでに提示しています。これにより、データベースサーバーだけに影響する Playbook またはロール内でファイアウォールルールを定義できます。

en: Example: Group by location
ja: 例: 場所別にグループ化

en: Other tasks might be focused on where a certain host is located. Let's say that ``db01.test.example.com`` and ``app01.test.example.com`` are located in DC1 while ``db02.test.example.com`` is in DC2:
ja: また、特定のホストがどこにあるかに焦点を当てたタスクもあります。たとえば、``db01.test.example.com`` と ``app01.test.example.com`` が DC1 にあり、``db02.test.example.com`` が DC2 にあるとします。

en: In practice, you might even end up mixing all these setups as you might need to, on one day, update all nodes in a specific data center while, on another day, update all the application servers no matter their location.
ja: 実際には、たとえば特定のデータセンター内のすべてのノードを更新する日と、置かれている場所に関係なくすべてのアプリケーションサーバーを更新する日が必要になるため、これらすべての設定を組み合わせて使用することがあります。

en: Pulling inventory from dynamic or static sources
ja: 動的ソースまたは静的ソースからのインベントリーのプル

en: Pulling inventory from dynamic sources, such as cloud providers
ja: クラウドプロバイダーなどの動的ソースからのインベントリーのプル

en: Learning Ansible's configuration, deployment, and orchestration language.
ja: Ansible の設定、デプロイメント、およびオーケストレーション言語について

en: Patterns: targeting hosts and groups
ja: パターン: ホストおよびグループを対象とする

en: When you execute Ansible through an ad hoc command or by running a playbook, you must choose which managed nodes or groups you want to execute against. Patterns let you run commands and playbooks against specific hosts and/or groups in your inventory. An Ansible pattern can refer to a single host, an IP address, an inventory group, a set of groups, or all hosts in your inventory. Patterns are highly flexible - you can exclude or require subsets of hosts, use wildcards or regular expressions, and more. Ansible executes on all inventory hosts included in the pattern.
ja: アドホックコマンドまたは Playbook から Ansible を実行する場合は、実行する管理ノードまたはグループを選択する必要があります。パターンにより、インベントリー内の特定のホストやグループに対してコマンドと Playbook を実行できます。Ansible パターンは、1 台のホスト、IP アドレス、インベントリーグループ、グループセット、またはインベントリー内のすべてのホストを参照できます。パターンは柔軟性が高く、ホストのサブセットを除外または要求したり、ワイルドカードや正規表現を使用したりできます。Ansible は、パターンに含まれるすべてのインベントリーホストで実行します。

en: Using patterns
ja: パターンの使用

en: You use a pattern almost any time you execute an ad hoc command or a playbook. The pattern is the only element of an :ref:`ad hoc command<intro_adhoc>` that has no flag. It is usually the second element::
ja: アドホックコマンドまたは Playbook を実行する際は、ほぼ常にパターンを使用します。パターンは、フラグのない :ref:`ad hoc command<intro_adhoc>` の唯一の要素です。通常は 2 番目の要素になります。

en: For example::
ja: 例::

en: In a playbook the pattern is the content of the ``hosts:`` line for each play:
ja: Playbook では、パターンは各プレイの ``hosts:`` 行の内容になります。

en: Since you often want to run a command or playbook against multiple hosts at once, patterns often refer to inventory groups. Both the ad hoc command and the playbook above will execute against all machines in the ``webservers`` group.
ja: 多くの場合は、コマンドまたは Playbook を複数のホストに対して一度に実行するため、パターンは多くの場合インベントリーグループを参照します。アドホックコマンドと上記の Playbook は、``webservers`` グループのすべてのマシンに対して実行されます。

en: Common patterns
ja: 一般的なパターン

en: This table lists common patterns for targeting inventory hosts and groups.
ja: 以下の表は、インベントリーホストおよびグループを対象に設定する一般的なパターンを示しています。

en: Description
ja: 説明

en: Pattern(s)
ja: パターン

en: Targets
ja: ターゲット

en: All hosts
ja: すべてのホスト

en: all (or \*)
ja: all (または \*)

en: One host
ja: 1 台のホスト

en: Multiple hosts
ja: 複数のホスト

en: host1:host2 (or host1,host2)
ja: host1:host2 (または host1,host2)

en: One group
ja: 1 つのグループ

en: Multiple groups
ja: 複数グループ

en: all hosts in webservers plus all hosts in dbservers
ja: webservers 上のすべてのホストと、dbservers 上のすべてのホスト

en: Excluding groups
ja: グループの除外

en: all hosts in webservers except those in atlanta
ja: atlanta 上のホストを除く webservers のすべてのホスト

en: Intersection of groups
ja: グループの交差部分

en: any hosts in webservers that are also in staging
ja: ステージ状態にある webservers のすべてのホスト

en: You can use either a comma (``,``) or a colon (``:``) to separate a list of hosts. The comma is preferred when dealing with ranges and IPv6 addresses.
ja: ホストのリストを分離するには、コンマ (``,``) またはコロン (``:``) のいずれかを使用できます。コンマは、範囲および IPv6 アドレスを処理する場合に推奨されます。

en: Once you know the basic patterns, you can combine them. This example::
ja: 基本的なパターンを把握したら、それを組み合わせることができます。以下に例を示します。

en: targets all machines in the groups 'webservers' and 'dbservers' that are also in the group 'staging', except any machines in the group 'phoenix'.
ja: 「phoenix」グループのマシンを除き、「staging」グループにある「webservers」グループおよび「dbservers」グループにあるすべてのマシンを対象とします。

en: You can use wildcard patterns with FQDNs or IP addresses, as long as the hosts are named in your inventory by FQDN or IP address::
ja: ホストがインベントリーで FQDN または IP アドレスにより名前が付けられている限り、FQDN または IP アドレスでワイルドカードパターンを使用できます。

en: You can mix wildcard patterns and groups at the same time::
ja: ワイルドカードパターンおよびグループを同時に組み合わせることができます。

en: Limitations of patterns
ja: パターンの制限

en: Patterns depend on inventory. If a host or group is not listed in your inventory, you cannot use a pattern to target it. If your pattern includes an IP address or hostname that does not appear in your inventory, you will see an error like this:
ja: パターンはインベントリーによって異なります。ホストまたはグループがインベントリーに記載されていない場合は、ターゲットにパターンを使用することはできません。インベントリーに表示されない IP アドレスまたはホスト名がパターンに含まれている場合は、以下のようなエラーが表示されます。

en: Your pattern must match your inventory syntax. If you define a host as an :ref:`alias<inventory_aliases>`:
ja: お使いのパターンはインベントリー構文に一致する必要があります。ホストを :ref:`エイリアス<inventory_aliases>` として定義する場合は、以下を指定します。

en: you must use the alias in your pattern. In the example above, you must use ``host1`` in your pattern. If you use the IP address, you will once again get the error::
ja: パターンでエイリアスを使用する必要があります。上記の例では、パターンで ``host1`` を使用する必要があります。IP アドレスを使用する場合は、エラーが再度表示されます。

en: Advanced pattern options
ja: 詳細なパターンオプション

en: The common patterns described above will meet most of your needs, but Ansible offers several other ways to define the hosts and groups you want to target.
ja: 上記の一般的なパターンはほとんどのニーズに対応しますが、Ansible では、対象とするホストおよびグループを定義する他の方法もいくつか提供します。

en: Using variables in patterns
ja: パターンにおける変数の使用

en: You can use variables to enable passing group specifiers via the ``-e`` argument to ansible-playbook::
ja: 変数を使うと、ansible-playbook の``-e`` 引数でグループ指定子を渡せるようになります。

en: Using group position in patterns
ja: パターンにおけるグループの位置の使用

en: You can define a host or subset of hosts by its position in a group. For example, given the following group::
ja: グループ内の位置によって、ホストやホストのサブセットを定義することができます。たとえば、次のようなグループが指定された場合です。

en: you can use subscripts to select individual hosts or ranges within the webservers group::
ja: subscripts を使用して、webservers グループ内のホストまたは範囲を個別に選択できます。

en: Using regexes in patterns
ja: パターンで正規表現の使用

en: You can specify a pattern as a regular expression by starting the pattern with ``~``::
ja: パターンを正規表現として指定するには、``~`` でパターンを開始します。

en: Patterns and ansible-playbook flags
ja: パターンおよび ansible-playbook フラグ

en: You can change the behavior of the patterns defined in playbooks using command-line options. For example, you can run a playbook that defines ``hosts: all`` on a single host by specifying ``-i 127.0.0.2,`` (note the trailing comma). This works even if the host you target is not defined in your inventory. You can also limit the hosts you target on a particular run with the ``--limit`` flag::
ja: コマンドラインオプションを使用して Playbook で定義したパターンの動作を変更できます。たとえば、``-i 127.0.0.2,`` (末尾のコンマ) を指定して、単一のホストで ``hosts: all`` を定義する Playbook を実行することができます。これは、対象とするホストがインベントリーに定義されていない場合でも有効です。また、``--limit`` フラグを使用して、特定の実行で対象とするホストを制限することもできます。

en: Finally, you can use ``--limit`` to read the list of hosts from a file by prefixing the file name with ``@``::
ja: 最後に ``--limit`` を使用して、ファイル名の前に ``@`` を付けることで、ファイルからホストのリストを読み込むことができます。

en: If :ref:`RETRY_FILES_ENABLED` is set to ``True``, a ``.retry`` file will be created after the ``ansible-playbook`` run containing a list of failed hosts from all plays. This file is overwritten each time ``ansible-playbook`` finishes running.
ja: :ref:`RETRY_FILES_ENABLED` が ``True`` に設定されている場合は、``ansible-playbook`` の実行後に、すべてのプレイで失敗したホストのリストを含む ``.retry`` ファイルが作成されます。このファイルは、``ansible-playbook`` の実行が終了するたびに上書きされます。

en: To apply your knowledge of patterns with Ansible commands and playbooks, read :ref:`intro_adhoc` and :ref:`playbooks_intro`.
ja: Ansible コマンドおよび Playbook でパターンに関する知識を活用するには、「:ref:`intro_adhoc`」および「:ref:`playbooks_intro`」を参照してください。

en: Learning the Ansible configuration management language
ja: Ansible の設定管理言語について

en: Windows Support
ja: Windows サポート

en: This page has been split up and moved to the new section :ref:`windows`.
ja: 本ページは分割し、新しいセクション :ref:`windows` に移動しました。

en: Working With Modules
ja: モジュールの使用

en: Ansible ships with a number of modules (called the 'module library') that can be executed directly on remote hosts or through :ref:`Playbooks <working_with_playbooks>`.
ja: Ansible には、リモートホスト上または :ref:`Playbooks <working_with_playbooks>` を介して直接実行できる多数のモジュール (「モジュールライブラリー」と呼ばれている) が同梱されています。

en: Users can also write their own modules. These modules can control system resources, like services, packages, or files (anything really), or handle executing system commands.
ja: ユーザーは自分でモジュールを書くこともできます。これらのモジュールは、サービス、パッケージ、ファイルなど (実際にはなんでも) のシステムリソースを制御したり、システムコマンドを実行することができます。

en: Examples of using modules in /usr/bin/ansible
ja: /usr/bin/ansible におけるモジュールの使用例

en: Introduction to using modules with /usr/bin/ansible-playbook
ja: /usr/bin/ansible-playbook におけるモジュール使用の概要

en: How to write your own modules
ja: 独自のモジュールの作成方法

en: Examples of using modules with the Python API
ja: Python API でモジュールを使用する例

en: Configuring the right Python interpreter on target hosts
ja: ターゲットホストでの適切な Python インタープリターの設定

en: Introduction to modules
ja: モジュールの概要

en: Modules (also referred to as "task plugins" or "library plugins") are discrete units of code that can be used from the command line or in a playbook task. Ansible executes each module, usually on the remote managed node, and collects return values. In Ansible 2.10 and later, most modules are hosted in collections.
ja: モジュール (「タスクプラグイン」または「ライブラリープラグイン」とも呼ばれる) は、コマンドラインまたは Playbook タスクで使用可能なコードの個別単位です。Ansible は、各モジュールを実行し、通常のリモート管理ノードで実行し、戻り値を収集します。Ansible 2.10 以降では、ほとんどのモジュールはコレクションでホストされます。

en: You can execute modules from the command line::
ja: コマンドラインからモジュールを実行できます。

en: Each module supports taking arguments.  Nearly all modules take ``key=value`` arguments, space delimited.  Some modules take no arguments, and the command/shell modules simply take the string of the command you want to run.
ja: 各モジュールは、引数を取ることをサポートしています。ほぼすべてのモジュールは、スペースで区切られた ``key=value`` の引数を取ります。一部のモジュールは引数を取らず、コマンド/シェルモジュールは単に実行したいコマンドの文字列を取ります。

en: From playbooks, Ansible modules are executed in a very similar way::
ja: Playbook から、Ansible モジュールは同じような方法で実行されます。

en: Another way to pass arguments to a module is using YAML syntax, also called 'complex args' ::
ja: もしくは、「complex args」とも呼ばれる YAML 構文を使用して、モジュールに引数を渡します。

en: All modules return JSON format data. This means modules can be written in any programming language. Modules should be idempotent, and should avoid making any changes if they detect that the current state matches the desired final state. When used in an Ansible playbook, modules can trigger 'change events' in the form of notifying :ref:`handlers <handlers>` to run additional tasks.
ja: すべてのモジュールは JSON 形式のデータを返します。これは、どのプログラミング言語でもモジュールを作成できます。モジュールは冪等であり、現在の状態が必要な最終状態と一致することを検知すると、変更は回避する必要があります。Ansible Playbook で使用すると、モジュールは :ref:`handlers <handlers>` に通知する形式で「変更イベント」をトリガーして追加のタスクを実行できます。

en: You can access the documentation for each module from the command line with the ansible-doc tool::
ja: 各モジュールのドキュメントは、ansible-doc ツールを使用してコマンドラインからアクセスできます。

en: For a list of all available modules, see the :ref:`Collection docs <list_of_collections>`, or run the following at a command prompt::
ja: 利用可能なモジュールの一覧は、「:ref:`Collection docs <list_of_collections>`」を参照してください。または、コマンドプロンプトで次のコマンドを実行します。

en: Examples of using modules with /usr/bin/ansible-playbook
ja: /usr/bin/ansible-playbook でモジュールを使用する例

en: Module Maintenance & Support
ja: モジュールのメンテナンスおよびサポート

en: If you are using a module and you discover a bug, you may want to know where to report that bug, who is responsible for fixing it, and how you can track changes to the module. If you are a Red Hat subscriber, you may want to know whether you can get support for the issue you are facing.
ja: モジュールを使用し、バグを発見した場合は、そのバグの報告場所、修正を行う担当者、およびモジュールへの変更を追跡する方法を把握することが推奨されます。Red Hat のサブスクリプションをお持ちの場合は、アクセスする問題のサポートを取得できるかどうかを認識できます。

en: Starting in Ansible 2.10, most modules live in collections. The distribution method for each collection reflects the maintenance and support for the modules in that collection.
ja: Ansible 2.10 以降、ほとんどのモジュールはコレクションに存在します。各コレクションのディストリビューション方法は、そのコレクションのモジュールに対するメンテナンスとサポートを反映しています。

en: Maintenance
ja: メンテナンス

en: Collection
ja: コレクション

en: Code location
ja: コードの場所

en: Maintained by
ja: メンテナンス担当

en: `ansible/ansible repo`_ on GitHub
ja: GitHub の `ansible/ansible repo`_

en: core team
ja: core チーム

en: distributed on Galaxy
ja: Galaxy への配布

en: various; follow ``repo`` link
ja: さまざま。``repo`` リンクに従ってください。

en: community or partners
ja: コミュニティーまたはパートナー

en: distributed on Automation Hub
ja: Automation Hub への配布

en: content team or partners
ja: コンテンツチームまたはパートナー

en: Issue Reporting
ja: 問題の報告

en: If you find a bug that affects a plugin in the main Ansible repo, also known as ``ansible-core``:
ja: Ansible メインリポジトリー (``ansible-core`` とも知られている) のプラグインに影響するバグを見つけた場合は、以下を行います。

en: Confirm that you are running the latest stable version of Ansible or the devel branch.
ja: Ansible の最新の安定版または devel ブランチを実行していることを確認します。

en: Look at the `issue tracker in the Ansible repo <https://github.com/ansible/ansible/issues>`_ to see if an issue has already been filed.
ja: `Ansible リポジトリーの問題トラッカー <https://github.com/ansible/ansible/issues>`_ を確認して、問題がすでに報告されているかどうかを確認します。

en: Create an issue if one does not already exist. Include as much detail as you can about the behavior you discovered.
ja: 問題が存在しない場合は、問題を作成してください。発見した動作について、できる限り詳細に記述してください。

en: If you find a bug that affects a plugin in a Galaxy collection:
ja: Galaxy コレクションでプラグインに影響を与えるバグを見つけた場合は、以下を行います。

en: Find the collection on Galaxy.
ja: Galaxy のコレクションを見つけます。

en: Find the issue tracker for the collection.
ja: コレクションの問題トラッカーの検索

en: Look there to see if an issue has already been filed.
ja: 問題がすでに報告されているかどうかを確認します。

en: Some partner collections may be hosted in private repositories.
ja: 一部のパートナーコレクションは、プライベートリポジトリーでホストされる場合があります。

en: If you are not sure whether the behavior you see is a bug, if you have questions, if you want to discuss development-oriented topics, or if you just want to get in touch, use one of our Google groups or IRC channels to :ref:`communicate with Ansiblers <communication>`.
ja: ご覧になった動作がバグなのかどうかわからない場合、質問がある場合、開発関連のトピックについて議論したい場合、または単に連絡を取りたい場合は、Google グループまたは IRC チャンネルのいずれかを使用して、:ref:`Ansible ユーザーと交流 <communication>` してください。

en: If you find a bug that affects a module in an Automation Hub collection:
ja: Automation Hub コレクションでモジュールに影響するバグを見つけた場合は、以下を行います。

en: If the collection offers an Issue Tracker link on Automation Hub, click there and open an issue on the collection repository. If it does not, follow the standard process for reporting issues on the `Red Hat Customer Portal <https://access.redhat.com/>`_. You must have a subscription to the Red Hat Ansible Automation Platform to create an issue on the portal.
ja: コレクションで Automation Hub 上の Issue Tracker リンクが提供されている場合、そこをクリックして、コレクションのリポジトリーに問題を作成します。指定していない場合は、`Red Hat カスタマーポータル <https://access.redhat.com/>`_ で問題を報告するための標準的なプロセスに従ってください。ポータルで問題を作成するには、Red Hat Ansible Automation Platform のサブスクリプションが必要です。

en: Support
ja: サポート

en: All plugins that remain in ``ansible-core`` and all collections hosted in Automation Hub are supported by Red Hat. No other plugins or collections are supported by Red Hat. If you have a subscription to the Red Hat Ansible Automation Platform, you can find more information and resources on the `Red Hat Customer Portal. <https://access.redhat.com/>`_
ja: ``ansible-core`` にあるすべてのプラグインと、Automation Hub でホストされるすべてのプラグインは Red Hat によってサポートされます。その他のプラグインまたはコレクションは Red Hat ではサポートされません。Red Hat Ansible Automation Platform にサブスクリプションがある場合は、`Red Hat カスタマーポータル <https://access.redhat.com/>`_ に関する詳細情報とリソースを確認できます。

en: Search paths in Ansible
ja: Ansible でパスの検索

en: You can control the paths Ansible searches to find resources on your control node (including configuration, modules, roles, ssh keys, and more) as well as resources on the remote nodes you are managing. Use absolute paths to tell Ansible where to find resources whenever you can. However, absolute paths are not always practical. This page covers how Ansible interprets relative search paths, along with ways to troubleshoot when Ansible cannot find the resource you need.
ja: Ansible がコントロールノード上のリソース (構成、モジュール、ロール、ssh キーなど) や、管理しているリモートノード上のリソースを検索する際のパスを制御できます。リソースを検索する場所を Ansible に伝えるには、可能な限り絶対パスを使用します。しかし、絶対パスは必ずしも実用的ではありません。このページでは、Ansible が相対検索パスをどのように解釈するか、また Ansible が必要なリソースを見つけられない場合のトラブルシューティングの方法について説明します。

en: Config paths
ja: 設定パス

en: By default these should be relative to the config file, some are specifically relative to the current working directory or the playbook and should have this noted in their description. Things like ssh keys are left to use the current working directory because it mirrors how the underlying tools would use it.
ja: デフォルトでは、これらは設定ファイルからの相対的なものですが、中には特に現在の作業ディレクトリーや Playbook からの相対的なものもあるため、説明にその旨を記載してください。ssh キーのようなものは、基本的なツールが使用する方法を反映するため、現在の作業ディレクトリーを使用するようになっています。

en: Task paths
ja: タスクパス

en: Task paths include two different scopes: task evaluation and task execution. For task evaluation, all paths are local, like in lookups. For task execution, which usually happens on the remote nodes, local paths do not usually apply. However, if a task uses an action plugin, it uses a local path. The template and copy modules are examples of modules that use action plugins, and therefore use local paths.
ja: タスクパスには、タスクの評価とタスクの実行という 2 つの異なるスコープがあります。タスクの評価では、ルックアップのようにすべてのパスがローカルになります。タスクの実行は通常リモートノードで行われるため、ローカルパスは通常適用されません。ただし、タスクがアクションプラグインを使用する場合は、ローカルパスを使用します。アクションプラグインを使用するモジュールの例としては、template モジュールと copy モジュールがあり、ローカルパスを使用します。

en: The magic of 'local' paths
ja: 「ローカル」パスのマジック

en: Lookups and action plugins both use a special 'search magic' to find things, taking the current play into account, it uses from most specific to most general playbook dir in which a task is contained (this includes roles and includes).
ja: lookup および action プラグインはどちらも特殊な「検索マジック」を使用します。これには現在のプレイが考慮され、タスクが含まれる Playbook ディレクトリー (これにはロールとインクルードを含む) で、より具体的な指定からより一般的な指定が使用されます。

en: Using this magic, relative paths get attempted first with a 'files|templates|vars' appended (if not already present), depending on action being taken, 'files' is the default. (in other words, include_vars will use vars/).  The paths will be searched from most specific to most general (in other words, role before play). dependent roles WILL be traversed (in other words, task is in role2, role2 is a dependency of role1, role2 will be looked at first, then role1, then play). i.e ::
ja: このマジックを使用すると、相対パスが存在していない場合は、最初に「files|templates|vars」を付加して試行されます。実行されるアクションによっては「files」がデフォルトになります (つまり、include_vars は vars/ を使用します)。パスは、最も具体的なものから最も一般的なものへ検索されます (つまり、play の前に role があります)。依存するロールは、横断されます (つまり、タスクが role2 にあり、role2 が role1 の依存関係にある場合は、role2 が最初に検索され、次に role1、そして play が検索されます)。つまり、以下のようになります。

en: By default, Ansible does not search the current working directory unless it happens to coincide with one of the paths above. If you `include` a task file from a role, it  will NOT trigger role behavior, this only happens when running as a role, `include_role` will work. A new variable `ansible_search_path` var will have the search path used, in order (but without the appended subdirs). Using 5 "v"s (`-vvvvv`) should show the detail of the search as it happens.
ja: デフォルトでは、Ansible は上記のパスのいずれかに一致しない限り、現在の作業ディレクトリーを検索しません。ロールからタスクファイルを `include` した場合は、ロールの動作を誘発することはありません。これはロールとして実行した場合にのみ発生し、`include_role` は動作します。新しい変数 `ansible_search_path` には、使用される検索パスが順番に入ります (ただし、付加されたサブディレクトリーは含まれません)。5つの「v」(`-vvvvv`) を使用して、検索の詳細を表示します。

en: As for includes, they try the path of the included file first and fall back to the play/role that includes them.
ja: インクルードに関しては、最初にインクルードされたファイルのパスを試し、そのファイルを含むプレイまたはロールにフォールバックします。

en: Working with playbooks
ja: Playbook の操作

en: Playbooks record and execute Ansible's configuration, deployment, and orchestration functions. They can describe a policy you want your remote systems to enforce, or a set of steps in a general IT process.
ja: Playbook は、Ansible の設定、デプロイメント、オーケストレーション機能を記録して実行します。リモートシステムを強制するポリシーや、一般的な IT プロセスで一連の手順を説明することができます。

en: If Ansible modules are the tools in your workshop, playbooks are your instruction manuals, and your inventory of hosts are your raw material.
ja: Ansible モジュールがワークショップのツールである場合、Playbook は手順のマニュアルにあり、ホストのインベントリーは実際のマテリアルになります。

en: At a basic level, playbooks can be used to manage configurations of and deployments to remote machines.  At a more advanced level, they can sequence multi-tier rollouts involving rolling updates, and can delegate actions to other hosts, interacting with monitoring servers and load balancers along the way.
ja: 基本的なレベルでは、Playbook を使用して、リモートマシンの設定およびリモートマシンへのデプロイメントを管理できます。より高度なレベルでは、ローリングアップデートに関連する複数層のロールアウトを分類し、他のホストにアクションを委譲して、監視サーバーやロードバランサーと対話できます。

en: Playbooks are designed to be human-readable and are developed in a basic text language.  There are multiple ways to organize playbooks and the files they include, and we'll offer up some suggestions on that and making the most out of Ansible.
ja: Playbook は人間が判読可能で、基本的なテキスト言語で開発されるように設計されています。Playbook と、Playbook に含まれるファイルを整理する方法は複数あり、その方法と、Ansible を最大限に活用するための提案を行います。

en: You should look at `Example Playbooks <https://github.com/ansible/ansible-examples>`_ while reading along with the playbook documentation.  These illustrate best practices as well as how to put many of the various concepts together.
ja: Playbook ドキュメントと一緒に、「`Example Playbooks <https://github.com/ansible/ansible-examples>`_」を参照してください。ここでは、ベストプラクティスや、さまざまな概念をまとめて配置する方法を説明します。

en: Advanced Syntax
ja: 高度な構文

en: The advanced YAML syntax examples on this page give you more control over the data placed in YAML files used by Ansible. You can find additional information about Python-specific YAML in the official `PyYAML Documentation <https://pyyaml.org/wiki/PyYAMLDocumentation#YAMLtagsandPythontypes>`_.
ja: このページの高度な YAML 構文の例では、Ansible が使用する YAML ファイルに配置されるデータをより細かく制御できます。Python 固有の YAML に関する追加情報は、公式 `PyYAML ドキュメント <https://pyyaml.org/wiki/PyYAMLDocumentation#YAMLtagsandPythontypes>`_ でご覧いただけます。

en: Unsafe or raw strings
ja: 安全でない文字列または生の文字列

en: When handling values returned by lookup plugins, Ansible uses a data type called ``unsafe`` to block templating. Marking data as unsafe prevents malicious users from abusing Jinja2 templates to execute arbitrary code on target machines. The Ansible implementation ensures that unsafe values are never templated. It is more comprehensive than escaping Jinja2 with ``{% raw %} ... {% endraw %}`` tags.
ja: lookup プラグインから返される値を処理する際、Ansible は ``unsafe`` というデータタイプを使用してテンプレートをブロックします。データを安全ではないとマークすることで、悪意のあるユーザーが Jinja2 のテンプレートを悪用してターゲットマシンで任意のコードを実行することを防ぎます。Ansible の実装では、安全でない値が決してテンプレート化されないようにしています。``{% raw %} ... {% endraw %}`` タグで Jinja2 をエスケープするよりも包括的です。

en: You can use the same ``unsafe`` data type in variables you define, to prevent templating errors and information disclosure. You can mark values supplied by :ref:`vars_prompts<unsafe_prompts>` as unsafe. You can also use ``unsafe`` in playbooks. The most common use cases include passwords that allow special characters like ``{`` or ``%``, and JSON arguments that look like templates but should not be templated. For example:
ja: 定義した変数に同じ ``unsafe`` データ型を使用すると、テンプレートエラーや情報の漏えいを防ぐことができます。:ref:`vars_prompts<unsafe_prompts>` により提供された値を安全でないものとしてマーク付けできます。Playbook で ``unsafe`` を使用することもできます。最も一般的なユースケースには、テンプレートのような ``{`` や ``%`` などの特殊文字を許可するパスワードが含まれていますが、テンプレート化すべきではありません。以下に例を示します。

en: In a playbook::
ja: Playbook の場合は、以下のようになります。

en: For complex variables such as hashes or arrays, use ``!unsafe`` on the individual elements::
ja: ハッシュや配列などの複雑な変数の場合は、個々の要素で ``!unsafe`` を使用します。

en: YAML anchors and aliases: sharing variable values
ja: YAML アンカーおよびエイリアス: 変数値の共有

en: `YAML anchors and aliases <https://yaml.org/spec/1.2/spec.html#id2765878>`_ help you define, maintain, and use shared variable values in a flexible way. You define an anchor with ``&``, then refer to it using an alias, denoted with ``*``. Here's an example that sets three values with an anchor, uses two of those values with an alias, and overrides the third value::
ja: `YAML アンカーおよびエイリアス <https://yaml.org/spec/1.2/spec.html#id2765878>`_ は、柔軟な方法で共有変数の値を定義、維持、および使用するのに役立ちます。``&`` でアンカーを定義し、``*`` で示すエイリアスを使用して参照します。ここでは、アンカーで 3 つの値を設定し、エイリアスでこれらの値を 2 つ使用し、3 番目の値を上書きする例を以下に示します。

en: Here, ``app1`` and ``app2`` share the values for ``opts`` and ``port`` using the anchor ``&jvm_opts`` and the alias ``*jvm_opts``. The value for ``path`` is merged by ``<<`` or `merge operator <https://yaml.org/type/merge.html>`_.
ja: ここで、``app1`` および ``app2`` は、アンカー ``&jvm_opts`` およびエイリアス ``*jvm_opts`` を使用して、``opts`` と ``port`` の値を共有します。``path`` の値は、``<<`` または `merge operator <https://yaml.org/type/merge.html>`_ によってマージされます。

en: Anchors and aliases also let you share complex sets of variable values, including nested variables. If you have one variable value that includes another variable value, you can define them separately::
ja: アンカーおよびエイリアスを使用すると、入れ子になった変数など、複雑な変数値のセットを共有することもできます。ある変数値に別の変数値が含まれている場合は、その変数値を別々に定義することができます。

en: This is inefficient and, at scale, means more maintenance. To incorporate the version value in the name, you can use an anchor in ``app_version`` and an alias in ``custom_name``::
ja: これは非効率的であり、大規模な場合には、より多くのメンテナンスが行われます。名前に version の値を組み込むには、``app_version`` にアンカーと、``custom_name`` のエイリアスを使用できます。

en: Now, you can re-use the value of ``app_version`` within the value of  ``custom_name`` and use the output in a template::
ja: これで、``custom_name`` の値の ``app_version`` の値を再利用し、テンプレートで出力を使用できます。

en: You've anchored the value of ``version`` with the ``&my_version`` anchor, and re-used it with the ``*my_version`` alias. Anchors and aliases let you access nested values inside dictionaries.
ja: ``version`` の値を ``&my_version`` というアンカーで固定し、``*my_version`` というエイリアスで再利用しています。アンカーとエイリアスを使用することで、ディクショナリー内のネストした値にアクセスすることができます。

en: All about variables
ja: 変数の詳細

en: Doing complex data manipulation in Ansible
ja: Ansible での複雑なデータ操作の実行

en: Have a question?  Stop by the google group!
ja: ご質問はございますか。Google Group をご覧ください。

en: Asynchronous actions and polling
ja: 非同期アクションおよびポーリング

en: By default Ansible runs tasks synchronously, holding the connection to the remote node open until the action is completed. This means within a playbook, each task blocks the next task by default, meaning subsequent tasks will not run until the current task completes. This behavior can create challenges. For example, a task may take longer to complete than the SSH session allows for, causing a timeout. Or you may want a long-running process to execute in the background while you perform other tasks concurrently. Asynchronous mode lets you control how long-running tasks execute.
ja: デフォルトでは、Ansible はタスクを同期的に実行し、アクションが完了するまでリモートノードへの接続を維持します。つまり、Playbook 内では、デフォルトでは各タスクが次のタスクをブロックし、現在のタスクが完了するまで後続のタスクが実行されないことになります。この動作には課題があります。たとえば、あるタスクが SSH セッションの許容範囲を超えて完了するのに時間がかかり、タイムアウトが発生する場合があります。また、他のタスクを同時に実行している間、長時間実行するプロセスをバックグラウンドで実行したい場合もあります。非同期モードでは、長時間実行するタスクの実行方法を制御することができます。

en: Asynchronous ad hoc tasks
ja: 非同期アドホックタスク

en: You can execute long-running operations in the background with :ref:`ad hoc tasks <intro_adhoc>`. For example, to execute ``long_running_operation`` asynchronously in the background, with a timeout (``-B``) of 3600 seconds, and without polling (``-P``)::
ja: :ref:`ad hoc tasks <intro_adhoc>` を使用すると、バックグラウンドで長時間実行される操作を実行することができます。たとえば、``long_running_operation`` をバックグラウンドで非同期的に実行し、タイムアウト (``-B``) を 3600 秒に設定し、ポーリング (``-P``) を行わない場合は次のようになります。

en: To check on the job status later, use the ``async_status`` module, passing it the job ID that was returned when you ran the original job in the background::
ja: 後でジョブステータスを確認するには、``async_status`` モジュールを使用し、バックグラウンドで元のジョブの実行時に返されたジョブ ID を渡します。

en: Ansible can also check on the status of your long-running job automatically with polling. In most cases, Ansible will keep the connection to your remote node open between polls. To run for 30 minutes and poll for status every 60 seconds::
ja: Ansible は、ポーリングによって長時間実行するジョブの状態を自動的に確認することもできます。ほとんどの場合、Ansible はポーリングの間もリモートノードへの接続を維持します。30 分間実行し、60 秒ごとにステータスをポーリングするには次のようにします。

en: Poll mode is smart so all jobs will be started before polling begins on any machine. Be sure to use a high enough ``--forks`` value if you want to get all of your jobs started very quickly. After the time limit (in seconds) runs out (``-B``), the process on the remote nodes will be terminated.
ja: ポーリングモードは高性能であるため、どのマシンでもポーリングが開始する前にすべてのジョブが開始します。すべてのジョブを非常に迅速に開始したい場合は ``--forks`` を十分な高さにしてください。制限時間 (秒単位) がなくなると (``-B``)、リモートノードのプロセスは終了します。

en: Asynchronous mode is best suited to long-running shell commands or software upgrades. Running the copy module asynchronously, for example, does not do a background file transfer.
ja: 非同期モードは、長時間実行するシェルコマンドやソフトウェアのアップグレードに最適です。たとえば、copy モジュールを非同期で実行しても、バックグラウンドでのファイル転送は行われません。

en: Asynchronous playbook tasks
ja: 非同期 Playbook タスク

en: :ref:`Playbooks <working_with_playbooks>` also support asynchronous mode and polling, with a simplified syntax. You can use asynchronous mode in playbooks to avoid connection timeouts or to avoid blocking subsequent tasks. The behavior of asynchronous mode in a playbook depends on the value of `poll`.
ja: :ref:`Playbooks <working_with_playbooks>` は、非同期モードとポーリングもサポートしており、構文も簡素化されています。非同期モードを Playbook で使用すると、接続のタイムアウトや、後続タスクのブロックを回避できます。Playbook での非同期モードの動作は、`poll` の値に依存します。

en: Avoid connection timeouts: poll > 0
ja: 接続のタイムアウトの回避: poll > 0

en: If you want to set a longer timeout limit for a certain task in your playbook, use ``async`` with ``poll`` set to a positive value. Ansible will still block the next task in your playbook, waiting until the async task either completes, fails or times out. However, the task will only time out if it exceeds the timeout limit you set with the ``async`` parameter.
ja: Playbook 内の特定のタスクにより長いタイムアウト制限を設定する場合は、``async`` を使用し、``poll`` を正の値に設定します。Ansible は、Playbook 内に記載される次のタスクをブロックし、非同期タスクが完了するか、失敗するか、タイムアウトになるまで待機します。ただし、タスクがタイムアウトになるのは、``async`` パラメーターで設定したタイムアウト制限を超えた場合のみです。

en: To avoid timeouts on a task, specify its maximum runtime and how frequently you would like to poll for status::
ja: タスクでタイムアウトを回避するには、最大ランタイムとステータスをポーリングする頻度を指定します。

en: The default poll value is set by the :ref:`DEFAULT_POLL_INTERVAL` setting. There is no default for the async time limit.  If you leave off the 'async' keyword, the task runs synchronously, which is Ansible's default.
ja: デフォルトのポール値は、:ref:`DEFAULT_POLL_INTERVAL` の設定で設定されます。非同期時間制限のデフォルトはありません。「async」キーワードを省略すると、タスクは同期的に実行されます。これが Ansible のデフォルトです。

en: As of Ansible 2.3, async does not support check mode and will fail the task when run in check mode. See :ref:`check_mode_dry` on how to skip a task in check mode.
ja: Ansible 2.3 の時点では、非同期は確認モードをサポートしておらず、確認モードで実行するとタスクが失敗します。確認モードでタスクをスキップする方法は、「:ref:`check_mode_dry`」を参照してください。

en: When an async task completes with polling enabled, the temporary async job cache file (by default in ~/.ansible_async/) is automatically removed.
ja: ポーリングを有効にして非同期タスクが完了すると、一時的な非同期ジョブキャッシュファイル (デフォルトでは ~/.ansible_async/ にある) が自動的に削除されます。

en: Run tasks concurrently: poll = 0
ja: タスクの同時実行: poll = 0

en: If you want to run multiple tasks in a playbook concurrently, use ``async`` with ``poll`` set to 0. When you set ``poll: 0``, Ansible starts the task and immediately moves on to the next task without waiting for a result. Each async task runs until it either completes, fails or times out (runs longer than its ``async`` value). The playbook run ends without checking back on async tasks.
ja: Playbook 内の複数のタスクを同時に実行する場合は、``async`` を使用し、``poll`` を 0 に設定します。``poll: 0`` を設定すると、Ansible はタスクを開始し、結果を待たずに直ちに次のタスクに移ります。各非同期タスクは、完了するか、失敗するか、タイムアウトにする (``async`` の値よりも長く実行される) まで実行されます。Playbook の実行は、非同期タスクを再度チェックせずに終了します。

en: To run a playbook task asynchronously::
ja: Playbook タスクを非同期的に実行するには、以下を実行します。

en: Do not specify a poll value of 0 with operations that require exclusive locks (such as yum transactions) if you expect to run other commands later in the playbook against those same resources.
ja: 排他的ロックを必要とする操作 (yum トランザクションなど) では、同じリソースに対して Playbook の後半で他のコマンドを実行することを想定して、poll 値に 0 を指定しないでください。

en: Using a higher value for ``--forks`` will result in kicking off asynchronous tasks even faster. This also increases the efficiency of polling.
ja: ``--forks`` の値を増やすと、非同期タスクの開始が速くなります。これにより、ポーリングの効率が高まります。

en: When running with ``poll: 0``, Ansible will not automatically cleanup the async job cache file. You will need to manually clean this up with the :ref:`async_status <async_status_module>` module with ``mode: cleanup``.
ja: ``poll: 0`` で実行すると、Ansible は非同期ジョブキャッシュファイルを自動的にクリーンアップしません。``mode: cleanup`` で:ref:`async_status <async_status_module>` モジュールを使用して手動でクリーンアップする必要があります。

en: If you need a synchronization point with an async task, you can register it to obtain its job ID and use the :ref:`async_status <async_status_module>` module to observe it in a later task. For example::
ja: 非同期タスクとの同期ポイントが必要な場合は、これを登録してジョブ ID を取得し、:ref:`async_status <async_status_module>` モジュールを使用して後続のタスクで確認することができます。以下に例を示します。

en: If the value of ``async:`` is not high enough, this will cause the "check on it later" task to fail because the temporary status file that the ``async_status:`` is looking for will not have been written or no longer exist
ja: ``async:`` の値が十分に高くない場合は、``async_status:`` が探している一時的なステータスファイルが書き込まれていないか、存在しなくなったため、「後で確認する」タスクが失敗することになります。

en: To run multiple asynchronous tasks while limiting the number of tasks running concurrently::
ja: 複数の非同期タスクを実行しながら、同時に実行するタスクの数を制限するには、以下を行います。

en: Options for controlling playbook execution
ja: Playbook の実行を制御するオプション

en: `User Mailing List <https://groups.google.com/group/ansible-devel>`_
ja: `ユーザーメーリングリスト <https://groups.google.com/group/ansible-devel>`_

en: Tips and tricks
ja: ヒントと裏技

en: These tips and tricks have helped us optimize our Ansible usage, and we offer them here as suggestions. We hope they will help you organize content, write playbooks, maintain inventory, and execute Ansible. Ultimately, though, you should use Ansible in the way that makes most sense for your organization and your goals.
ja: これらのヒントとコツは、Ansible の使用法を最適化するのに役に立ったため、提案としてここに示します。コンテンツの整理、Playbook の作成、インベントリーの維持、Ansible の実行に役立つことを願っています。ただし、最終的には、自身の組織と目標に最も適した方法で Ansible を使用する必要があります。

en: General tips
ja: 一般的なヒント

en: These concepts apply to all Ansible activities and artifacts.
ja: この概念は、すべての Ansible アクティビティーおよびアーティファクトに適用されます。

en: Keep it simple
ja: シンプルのままにする

en: Whenever you can, do things simply. Use advanced features only when necessary, and select the feature that best matches your use case. For example, you will probably not need ``vars``, ``vars_files``, ``vars_prompt`` and ``--extra-vars`` all at once, while also using an external inventory file. If something feels complicated, it probably is. Take the time to look for a simpler solution.
ja: できる限りシンプルに。高度な機能は必要な場合にのみ使用し、自身のユースケースに最も一致した機能を選択してください。たとえば、外部のインベントリーファイルを使用しながら、``vars``、``vars_files``、``vars_prompt``、および ``--extra-vars`` を一度に使用することはないでしょう。何かが複雑に感じられる場合は、おそらく複雑なのです。時間をかけて、よりシンプルなソリューションを探してみてください。

en: Use version control
ja: バージョン制御を使用する

en: Keep your playbooks, roles, inventory, and variables files in git or another version control system and make commits to the repository when you make changes. Version control gives you an audit trail describing when and why you changed the rules that automate your infrastructure.
ja: Playbook、ロール、インベントリー、変数などのファイルを git などのバージョン管理システムで管理し、変更があった場合はリポジトリーにコミットします。バージョン管理は、インフラストラクチャーを自動化するルールをいつ、なぜ変更したかを示す監査証跡となります。

en: Playbook tips
ja: Playbook のヒント

en: These tips help make playbooks and roles easier to read, maintain, and debug.
ja: このヒントは、Playbook とロールの読み取り、維持、およびデバッグを容易にするのに役立ちます。

en: Use whitespace
ja: 空白を使用する

en: Generous use of whitespace, for example, a blank line before each block or task, makes a playbook easy to scan.
ja: 各ブロックやタスクの前に空の行など、空白を使用すると Playbook を簡単にスキャンできます。

en: Always name tasks
ja: 常にタスクに名前を付ける

en: Task names are optional, but extremely useful. In its output, Ansible shows you the name of each task it runs. Choose names that describe what each task does and why.
ja: タスク名は任意ですが、非常に便利なものになります。その出力で、Ansible では、実行する各タスクの名前が記載されます。各タスクの機能や理由を説明する名前を選択します。

en: Always mention the state
ja: 状態について常に言及する

en: For many modules, the 'state' parameter is optional. Different modules have different default settings for 'state', and some modules support several 'state' settings. Explicitly setting 'state=present' or 'state=absent' makes playbooks and roles clearer.
ja: 多くのモジュールでは、「state」パラメーターは任意です。モジュールによって「state」のデフォルト設定は異なり、複数の「state」設定をサポートしているモジュールもあります。「state=present」や「state=absent」を明示的に設定することで、Playbook やロールがより明確になります。

en: Use comments
ja: コマンドを使用する

en: Even with task names and explicit state, sometimes a part of a playbook or role (or inventory/variable file) needs more explanation. Adding a comment (any line starting with '#') helps others (and possibly yourself in future) understand what a play or task (or variable setting) does, how it does it, and why.
ja: タスク名や状態が明示されていても、Playbook やロール (またはインベントリー/変数ファイル) の一部にさらに説明が必要な場合があります。コメント (「#」で始まる行) を追加することで、プレイやタスク (または変数設定) が何をどのように行うのか、またその理由を他のユーザー (そして将来的には自分自身) が理解するのに役立ちます。

en: Inventory tips
ja: インベントリーのヒント

en: These tips help keep your inventory well organized.
ja: これらのヒントは、インベントリーを十分に整理するのに役に立ちます。

en: Use dynamic inventory with clouds
ja: クラウドでの動的インベントリーの使用

en: With cloud providers and other systems that maintain canonical lists of your infrastructure, use :ref:`dynamic inventory <intro_dynamic_inventory>` to retrieve those lists instead of manually updating static inventory files. With cloud resources, you can use tags to differentiate production and staging environments.
ja: クラウドプロバイダーやその他のシステムがインフラストラクチャーの正規のリストを管理している場合は、静的なインベントリーファイルを手動で更新する代わりに、:ref:`dynamic inventory <intro_dynamic_inventory>` を使用してこれらのリストを取得します。クラウドリソースでは、タグを使用して本番環境とステージング環境を区別することができます。

en: Group inventory by function
ja: 機能別にインベントリーのグループ化

en: A system can be in multiple groups.  See :ref:`intro_inventory` and :ref:`intro_patterns`. If you create groups named for the function of the nodes in the group, for example *webservers* or *dbservers*, your playbooks can target machines based on function. You can assign function-specific variables using the group variable system, and design Ansible roles to handle function-specific use cases. See :ref:`playbooks_reuse_roles`.
ja: 1 つのシステムは複数のグループに属することができます。「:ref:`intro_inventory`」および「:ref:`intro_patterns`」を参照してください。*webservers*、*dbservers* など、グループ内のノードの機能に応じた名前のグループを作成すると、Playbook で機能に応じてマシンをターゲットにすることができます。グループ変数システムを使用して機能固有の変数を割り当て、機能固有のユースケースを処理するために Ansible ロールを設計することができます。「:ref:`playbooks_reuse_roles`」を参照してください。

en: Separate production and staging inventory
ja: 別個の実稼働およびステージングのインベントリー

en: You can keep your production environment separate from development, test, and staging environments by using separate inventory files or directories for each environment. This way you pick with -i what you are targeting. Keeping all your environments in one file can lead to surprises!
ja: 実稼働を開発環境、テスト環境、ステージング環境から分離するには、それぞれの環境に個別のインベントリーファイルまたはディレクトリーを使用します。この方法では、-i で対象となるものを選ぶことができます。すべての環境を 1 つのファイルにまとめておくと、驚くようなことが起こります。

en: Keep vaulted variables safely visible
ja: Vault 処理された変数を安全に表示

en: You should encrypt sensitive or secret variables with Ansible Vault. However, encrypting the variable names as well as the variable values makes it hard to find the source of the values. You can keep the names of your variables accessible (by ``grep``, for example) without exposing any secrets by adding a layer of indirection:
ja: 機密性の高い変数や秘密の変数は、Ansible Vault で暗号化する必要があります。しかし、変数名だけでなく変数の値も暗号化すると、値の出所を見つけるのが難しくなります。間接層を追加することで、秘密を公開することなく、変数の名前に (たとえば ``grep`` で) アクセスできる状態を維持することができます。

en: Create a ``group_vars/`` subdirectory named after the group.
ja: グループの名前が付けられた ``group_vars/`` サブディレクトリーを作成します。

en: Inside this subdirectory, create two files named ``vars`` and ``vault``.
ja: このサブディレクトリー内に、``vars`` と ``vault`` という名前のファイルを作成します。

en: In the ``vars`` file, define all of the variables needed, including any sensitive ones.
ja: ``vars`` ファイルで、機密性の高い変数など、必要な変数をすべて定義します。

en: Copy all of the sensitive variables over to the ``vault`` file and prefix these variables with ``vault_``.
ja: すべての機密変数を ``vault`` ファイルにコピーし、この変数の前に ``vault_`` を付けます。

en: Adjust the variables in the ``vars`` file to point to the matching ``vault_`` variables using jinja2 syntax: ``db_password: {{ vault_db_password }}``.
ja: jinja2 構文を使用して一致する ``vault_`` 変数を参照するように、``vars`` ファイルの変数を調整します (``db_password: {{ vault_db_password }}``)。

en: Encrypt the ``vault`` file to protect its contents.
ja: ``vault`` ファイルを暗号化することで、そのコンテンツを保護します。

en: Use the variable name from the ``vars`` file in your playbooks.
ja: Playbook の ``vars`` ファイルの変数名を使用します。

en: When running a playbook, Ansible finds the variables in the unencrypted file, which pulls the sensitive variable values from the encrypted file. There is no limit to the number of variable and vault files or their names.
ja: Playbook を実行する際、Ansible は暗号化されていないファイルの変数を見つけ、暗号化されたファイルから機密性の高い変数の値を引き出します。変数ファイルと Vault ファイルの数や名前に制限はありません。

en: Execution tricks
ja: 実行トリック

en: These tips apply to using Ansible, rather than to Ansible artifacts.
ja: このヒントは、Ansible アーティファクトではなく Ansible の使用に適用されます。

en: Try it in staging first
ja: 最初にステージングで試す

en: Testing changes in a staging environment before rolling them out in production is always a great idea.  Your environments need not be the same size and you can use group variables to control the differences between those environments.
ja: 変更を実稼働環境に展開する前にステージング環境でテストすることは、常に素晴らしい考えです。環境は同じ大きさである必要はなく、グループ変数を使用して環境間の違いを制御することができます。

en: Update in batches
ja: バッチの更新

en: Use the 'serial' keyword to control how many machines you update at once in the batch. See :ref:`playbooks_delegation`.
ja: 「serial」キーワードを使用して、バッチで一度にアップデートするマシンの数を制御します。「:ref:`playbooks_delegation`」を参照してください。

en: Handling OS and distro differences
ja: OS とディストリビューションの相違点の処理

en: Group variables files and the ``group_by`` module work together to help Ansible execute across a range of operating systems and distributions that require different settings, packages, and tools. The ``group_by`` module creates a dynamic group of hosts matching certain criteria. This group does not need to be defined in the inventory file. This approach lets you execute different tasks on different operating systems or distributions. For example::
ja: グループ変数ファイルと ``group_by`` モジュールが連携することで、Ansible は、異なる設定、パッケージ、ツールを必要とするさまざまなオペレーティングシステムやディストリビューションに対応して実行することができます。``group_by`` モジュールは、特定の条件に一致するホストの動的グループを作成します。このグループは、インベントリーファイルで定義する必要はありません。この方法では、異なるオペレーティングシステムやディストリビューション上で異なるタスクを実行することができます。以下に例を示します。

en: The first play categorizes all systems into dynamic groups based on the operating system name. Later plays can use these groups as patterns on the ``hosts`` line. You can also add group-specific settings in group vars files. All three names must match: the name created by the ``group_by`` task, the name of the pattern in subsequent plays, and the name of the group vars file. For example::
ja: 最初のプレイでは、すべてのシステムをオペレーティングシステムの名前に基づいて動的なグループに分類します。後のプレイでは、これらのグループを ``hosts`` 行のパターンとして使用できます。また、グループの変数ファイルでグループ固有の設定を追加することもできます。``group_by`` タスクで作成された名前、後続のプレイでのパターンの名前、グループの変数ファイルの名前の 3 つの名前がすべて一致する必要があります。以下に例を示します。

en: In this example, CentOS machines get the value of '42' for asdf, but other machines get '10'. This can be used not only to set variables, but also to apply certain roles to only certain systems.
ja: この例では、CentOS マシンでは asdf に「42」という値が設定されますが、その他のマシンでは「10」が設定されます。これは、変数の設定だけでなく、特定のシステムだけに特定のロールを適用するためにも使用できます。

en: You can use the same setup with ``include_vars`` when you only need OS-specific variables, not tasks::
ja: タスクではなく、OS 固有の変数のみを必要とする場合は、``include_vars`` で同じ設定を使用できます。

en: This pulls in variables from the group_vars/os_CentOS.yml file.
ja: これにより、group_vars/os_CentOS.yml ファイルから変数がプルされます。

en: Learn about YAML syntax
ja: YAML 構文について

en: Review the basic playbook features
ja: 基本的な Playbook 機能の確認

en: Learn how to extend Ansible by writing your own modules
ja: 独自のモジュールを作成して Ansible を拡張する方法について

en: Learn about how to select hosts
ja: ホストの選択方法について

en: `GitHub examples directory <https://github.com/ansible/ansible-examples>`_
ja: `GitHub サンプルディレクトリー <https://github.com/ansible/ansible-examples>`_

en: Complete playbook files from the github project source
ja: Github プロジェクトソースの完全な Playbook ファイル

en: Blocks
ja: ブロック

en: Blocks create logical groups of tasks. Blocks also offer ways to handle task errors, similar to exception handling in many programming languages.
ja: ブロックは、タスクの論理的なグループを作ります。また、ブロックにはタスクのエラーを処理する方法があり、多くのプログラミング言語の例外処理に似ています。

en: Grouping tasks with blocks
ja: ブロックを使用したタスクのグループ化

en: All tasks in a block inherit directives applied at the block level. Most of what you can apply to a single task (with the exception of loops) can be applied at the block level, so blocks make it much easier to set data or directives common to the tasks. The directive does not affect the block itself, it is only inherited by the tasks enclosed by a block. For example, a `when` statement is applied to the tasks within a block, not to the block itself.
ja: ブロック内のすべてのタスクは、ブロックレベルで適用されるディレクティブを継承します。単一のタスクに適用できるもの (ループを除く) のほとんどは、ブロックレベルで適用できるため、ブロックを使用すると、タスクに共通するデータやディレクティブを設定することが非常に簡単になります。ディレクティブはブロック自体には影響せず、ブロックで囲まれたタスクにのみ継承されます。たとえば、`when` 文は、ブロック自体にではなく、ブロック内のタスクに適用されます。

en: Block example with named tasks inside the block
ja: 内部に名前付きタスクを含むブロックの例

en: In the example above, the 'when' condition will be evaluated before Ansible runs each of the three tasks in the block. All three tasks also inherit the privilege escalation directives, running as the root user. Finally, ``ignore_errors: yes`` ensures that Ansible continues to execute the playbook even if some of the tasks fail.
ja: 上の例では、Ansible がブロック内の 3 つのタスクをそれぞれ実行する前に、「when」条件が評価されます。また、3 つのタスクはすべて、特権昇格ディレクティブを継承し、root ユーザーとして実行します。最後に、``ignore_errors: yes`` は、一部のタスクが失敗しても、Ansible が Playbook の実行を継続することを保証します。

en: Names for blocks have been available since Ansible 2.3. We recommend using names in all tasks, within blocks or elsewhere, for better visibility into the tasks being executed when you run the playbook.
ja: ブロックの名前は、Ansible 2.3 から利用できるようになりました。Playbook の実行時に実行されているタスクの可視性を高めるために、ブロック内やその他の場所で、すべてのタスクに名前を使用することが推奨されます。

en: Handling errors with blocks
ja: ブロックを使用したエラーの処理

en: You can control how Ansible responds to task errors using blocks with ``rescue`` and ``always`` sections.
ja: ``rescue`` セクションおよび ``always`` セクションのブロックを使用して、Ansible がタスクエラーに対応する方法を制御できます。

en: Rescue blocks specify tasks to run when an earlier task in a block fails. This approach is similar to exception handling in many programming languages. Ansible only runs rescue blocks after a task returns a 'failed' state. Bad task definitions and unreachable hosts will not trigger the rescue block.
ja: レスキューブロックは、ブロック内の先行タスクが失敗したときに実行するタスクを指定します。このアプローチは、多くのプログラミング言語における例外処理に似ています。Ansible は、タスクが「失敗」状態を返した後にのみレスキューブロックを実行します。誤ったタスク定義や到達不可能なホストでは、レスキューブロックは実行しません。

en: Block error handling example
ja: ブロックエラー処理例

en: You can also add an ``always`` section to a block. Tasks in the ``always`` section run no matter what the task status of the previous block is.
ja: ``always`` セクションをブロックに追加することもできます。前のブロックのタスクステータスに関係なく、``always`` セクションのタスクは実行します。

en: Block with always section
ja: always セクションのあるブロック

en: Together, these elements offer complex error handling.
ja: この要素をまとめると、複雑なエラー処理を行います。

en: Block with all sections
ja: すべてのセクションのブロック

en: The tasks in the ``block`` execute normally. If any tasks in the block return ``failed``, the ``rescue`` section executes tasks to recover from the error. The ``always`` section runs regardless of the results of the ``block`` and ``rescue`` sections.
ja: ``block`` のタスクは正常に実行されます。ブロック内のいずれかのタスクが ``failed`` を返すと、``rescue`` セクションはエラーから回復するためのタスクを実行します。``always`` セクションは、``block`` セクションと ``rescue`` セクションの結果に関わらず実行されます。

en: If an error occurs in the block and the rescue task succeeds, Ansible reverts the failed status of the original task for the run and continues to run the play as if the original task had succeeded. The rescued task is considered successful, and does not trigger ``max_fail_percentage`` or ``any_errors_fatal`` configurations. However, Ansible still reports a failure in the playbook statistics.
ja: ブロック内でエラーが発生し、レスキュータスクが成功した場合、Ansible は実行中の元のタスクの失敗ステータスを元に戻し、元のタスクが成功したかのようにプレイの実行を継続します。レスキューとなったタスクは成功したとみなされ、``max_fail_percentage`` や ``any_errors_fatal`` の設定は発生しません。ただし、Ansible は Playbook の統計で失敗を報告します。

en: You can use blocks with ``flush_handlers`` in a rescue task to ensure that all handlers run even if an error occurs:
ja: レスキュータスクにおいて ``flush_handlers`` でブロックを使用し、エラーが発生した場合でもすべてのハンドラーが実行されるようにします。

en: Block run handlers in error handling
ja: エラー処理におけるブロック実行ハンドラー

en: Ansible provides a couple of variables for tasks in the ``rescue`` portion of a block:
ja: Ansible は、ブロックの ``rescue`` の部分にタスクの変数をいくつか提供します。

en: The task that returned 'failed' and triggered the rescue. For example, to get the name use ``ansible_failed_task.name``.
ja: 「失敗した」と返され、レスキューのきっかけとなったタスクです。たとえば、名前を取得するには ``ansible_failed_task.name`` を使用します。

en: The captured return result of the failed task that triggered the rescue. This would equate to having used this var in the ``register`` keyword.
ja: レスキューをトリガーした失敗したタスクの戻り値。これは、``register`` キーワードでこの変数を使用するのと同じです。

en: Playbook organization by roles
ja: ロール別の Playbook の組織

en: Validating tasks: check mode and diff mode
ja: タスクの検証: 確認モードと差分モード

en: Ansible provides two modes of execution that validate tasks: check mode and diff mode. These modes can be used separately or together. They are useful when you are creating or editing a playbook or role and you want to know what it will do. In check mode, Ansible runs without making any changes on remote systems. Modules that support check mode report the changes they would have made. Modules that do not support check mode report nothing and do nothing. In diff mode, Ansible provides before-and-after comparisons. Modules that support diff mode display detailed information. You can combine check mode and diff mode for detailed validation of your playbook or role.
ja: Ansible には、タスクを検証するために、確認モードと差分モードという 2 つの実行モードが用意されています。これらのモードは、別々に使用することも、一緒に使用することもできます。これらのモードは、Playbook やロールを作成または編集する際に、その実行内容を知りたい場合に便利です。確認モードでは、Ansible はリモートシステムに変更を加えずに実行します。確認モードをサポートするモジュールは、自身が行った変更を報告します。確認モードをサポートしていないモジュールは、何も報告せず、何も行いません。差分モードでは、Ansible は事前と事後の比較を行います。差分モードをサポートするモジュールは、詳細情報を表示します。確認モードと差分モードを組み合わせて、Playbook やロールの詳細な検証を行うことができます。

en: Using check mode
ja: 確認モードの使用

en: Check mode is just a simulation. It will not generate output for tasks that use :ref:`conditionals based on registered variables <conditionals_registered_vars>` (results of prior tasks). However, it is great for validating configuration management playbooks that run on one node at a time. To run a playbook in check mode::
ja: 確認モードはあくまでもシミュレーションです。:ref:`登録変数に基づいた条件 <conditionals_registered_vars>` (先行タスクの結果) を使用するタスクの出力は生成されません。しかし、一度に 1 つのノードで実行する構成管理の Playbook を検証するには最適です。Playbook を確認モードで実行するには以下を行います。

en: Enforcing or preventing check mode on tasks
ja: タスクでの確認モードの強制または禁止

en: If you want certain tasks to run in check mode always, or never, regardless of whether you run the playbook with or without ``--check``, you can add the ``check_mode`` option to those tasks:
ja: Playbook を実行する際に ``--check`` を付けるかどうかに関わらず、特定のタスクを常に確認モードで実行する場合は、それらのタスクに ``check_mode`` オプションを追加します。

en: To force a task to run in check mode, even when the playbook is called without ``--check``, set ``check_mode: yes``.
ja: ``--check`` を使用せずに Playbook が呼び出された場合でも、タスクを強制的に確認モードで実行するには、``check_mode: yes`` を設定します。

en: To force a task to run in normal mode and make changes to the system, even when the playbook is called with ``--check``, set ``check_mode: no``.
ja: Playbook が ``--check`` で呼び出された場合でも、タスクを強制的に通常モードで実行し、システムに変更を加えるには、``check_mode: no`` を設定します。

en: Running single tasks with ``check_mode: yes`` can be useful for testing Ansible modules, either to test the module itself or to test the conditions under which a module would make changes. You can register variables (see :ref:`playbooks_conditionals`) on these tasks for even more detail on the potential changes.
ja: ``check_mode: yes`` を使用してシングルタスクを実行すると、Ansible モジュールをテストする際に便利です。モジュール自体をテストしたり、モジュールが変更を行う条件をテストしたりすることができます。これらのタスクに変数 (:ref:`playbooks_conditionals` を参照) を登録すると、潜在的な変更についてさらに詳しく知ることができます。

en: Prior to version 2.2 only the equivalent of ``check_mode: no`` existed. The notation for that was ``always_run: yes``.
ja: バージョン 2.2 以前では、``check_mode: no`` に相当するものだけが存在していました。その表記法は ``always_run: yes`` でした。

en: Skipping tasks or ignoring errors in check mode
ja: タスクをスキップまたは確認モードでエラーを無視する

en: If you want to skip a task or ignore errors on a task when you run Ansible in check mode, you can use a boolean magic variable ``ansible_check_mode``, which is set to ``True`` when Ansible runs in check mode. For example::
ja: Ansible を確認モードで実行する際に、タスクをスキップしたり、タスクのエラーを無視したりする場合は、ブール型のマジック変数 ``ansible_check_mode`` を使用することができます。この変数は、Ansible を確認モードで実行すると、``True`` に設定されます。以下に例を示します。

en: Using diff mode
ja: 差分モードの使用

en: The ``--diff`` option for ansible-playbook can be used alone or with ``--check``. When you run in diff mode, any module that supports diff mode reports the changes made or, if used with ``--check``, the changes that would have been made. Diff mode is most common in modules that manipulate files (for example, the template module) but other modules might also show 'before and after' information (for example, the user module).
ja: ansible-playbook の ``--diff`` オプションは、単独でも ``--check`` と併用しても構いません。差分モードで実行すると、差分モードをサポートしているすべてのモジュールが、行われた変更を報告します (``--check`` と併用する場合は、行われたであろう変更を報告します)。差分モードは、ファイルを操作するモジュール (template モジュールなど) で最も一般的ですが、その他のモジュールでも「変更前と変更後」の情報を表示することがあります (user モジュールなど)。

en: Diff mode produces a large amount of output, so it is best used when checking a single host at a time. For example::
ja: 差分モードは大量の出力を生成するため、一度に 1 つのホストを確認するときに使うのが最適です。以下に例を示します。

en: Enforcing or preventing diff mode on tasks
ja: タスクでの差分モードの強制または禁止

en: Because the ``--diff`` option can reveal sensitive information, you can disable it for a task by specifying ``diff: no``. For example::
ja: ``--diff`` オプションは機密情報を表示する可能性があるため、``diff: no`` を指定してタスクに対してこれを無効にすることができます。以下に例を示します。

en: Conditionals
ja: 条件 (Conditional)

en: In a playbook, you may want to execute different tasks, or have different goals, depending on the value of a fact (data about the remote system), a variable, or the result of a previous task. You may want the value of some variables to depend on the value of other variables. Or you may want to create additional groups of hosts based on whether the hosts match other criteria. You can do all of these things with conditionals.
ja: Playbook では、ファクト (リモートシステムに関するデータ)、変数、または以前のタスクの結果の値に応じて、異なるタスクを実行したり、異なるゴールを設定したりすることができます。また、ある変数の値に応じて別の変数の値を変更したい場合もあります。また、ホストが他の基準に一致するかどうかに基づいて、ホストの追加グループを作成することもできます。これらのことはすべて、条件分岐で実現できます。

en: Ansible uses Jinja2 :ref:`tests <playbooks_tests>` and :ref:`filters <playbooks_filters>` in conditionals. Ansible supports all the standard tests and filters, and adds some unique ones as well.
ja: Ansible は Jinja2 の :ref:`テスト <playbooks_tests>` および :ref:`フィルター <playbooks_filters>` を条件分岐で使用しています。Ansible は標準的なテストやフィルターをすべてサポートしており、独自のものもいくつか追加されています。

en: There are many options to control execution flow in Ansible. You can find more examples of supported conditionals at `<https://jinja.palletsprojects.com/en/master/templates/#comparisons>`_.
ja: Ansible で実行フローを制御するオプションは多数あります。サポートされている条件分岐の例は、`<https://jinja.palletsprojects.com/en/master/templates/#comparisons>`_ で確認できます。

en: Basic conditionals with ``when``
ja: ``when`` を使用する基本的な条件分岐

en: The simplest conditional statement applies to a single task. Create the task, then add a ``when`` statement that applies a test. The ``when`` clause is a raw Jinja2 expression without double curly braces (see :ref:`group_by_module`). When you run the task or playbook, Ansible evaluates the test for all hosts. On any host where the test passes (returns a value of True), Ansible runs that task. For example, if you are installing mysql on multiple machines, some of which have SELinux enabled, you might have a task to configure SELinux to allow mysql to run. You would only want that task to run on machines that have SELinux enabled:
ja: 最も簡単な条件文は、1 つのタスクに適用されるものです。タスクを作成し、テストを適用する ``when`` の文を追加します。``when`` 句は、二重中括弧のない生の Jinja2 式です (:ref:`group_by_module` 参照)。タスクや Playbook を実行すると、Ansible はすべてのホストに対してテストを評価します。テストにパスする (True の値を返す) ホストでは、Ansible はそのタスクを実行します。たとえば、複数のマシンに mysql をインストールし、そのうちのいくつかのマシンでは SELinux が有効になっている場合は、mysql の実行を許可するように SELinux を設定するタスクがあります。このタスクは、SELinux が有効になっているマシンでのみ実行されるようにします。

en: Conditionals based on ansible_facts
ja: ansible_facts に基づく条件分岐

en: Often you want to execute or skip a task based on facts. Facts are attributes of individual hosts, including IP address, operating system, the status of a filesystem, and many more. With conditionals based on facts:
ja: ファクトに基づいてタスクを実行したりスキップしたりしたい場合がよくあります。ファクトとは、IP アドレス、オペレーティングシステム、ファイルシステムの状態など、個々のホストの属性のことです。ファクトに基づく条件分岐で、以下を行います。

en: You can install a certain package only when the operating system is a particular version.
ja: 特定のパッケージは、オペレーティングシステムが特定のバージョンの場合にのみインストールできます。

en: You can skip configuring a firewall on hosts with internal IP addresses.
ja: 内部 IP アドレスを持つホストでファイアウォールの設定を省略できます。

en: You can perform cleanup tasks only when a filesystem is getting full.
ja: ファイルシステムが満杯になった場合にのみ、クリーンアップタスクを実行することができます。

en: See :ref:`commonly_used_facts` for a list of facts that frequently appear in conditional statements. Not all facts exist for all hosts. For example, the 'lsb_major_release' fact used in an example below only exists when the lsb_release package is installed on the target host. To see what facts are available on your systems, add a debug task to your playbook::
ja: 条件文に頻繁に現れるファクトの一覧は、:ref:`commonly_used_facts` を参照してください。すべてのファクトがすべてのホストに存在するわけではありません。たとえば、以下の例で使用されている「lsb_major_release」ファクトは、ターゲットホストに lsb_release パッケージがインストールされている場合にのみ存在します。システム上で利用可能なファクトを確認するには、Playbook にデバッグタスクを追加します。

en: Here is a sample conditional based on a fact:
ja: 以下は、ファクトに基づく条件分岐の例です。

en: If you have multiple conditions, you can group them with parentheses:
ja: 複数の条件がある場合は、括弧でグループ化できます。

en: You can use `logical operators <https://jinja.palletsprojects.com/en/master/templates/#logic>`_ to combine conditions. When you have multiple conditions that all need to be true (that is, a logical ``and``), you can specify them as a list::
ja: `論理演算子 <https://jinja.palletsprojects.com/en/master/templates/#logic>`_ を使用して条件を組み合わせることができます。すべてが True である必要がある複数の条件がある場合 (つまり、論理的な ``and``)、それらをリストとして指定することができます。

en: If a fact or variable is a string, and you need to run a mathematical comparison on it, use a filter to ensure that Ansible reads the value as an integer::
ja: ファクトまたは変数が文字列で、それに対して数学比較を実行する必要がある場合は、フィルターを使用して Ansible が値を整数として読み取るようにします。

en: Conditions based on registered variables
ja: 登録済みの変数に基づく条件

en: Often in a playbook you want to execute or skip a task based on the outcome of an earlier task. For example, you might want to configure a service after it is upgraded by an earlier task. To create a conditional based on a registered variable:
ja: Playbook では、以前のタスクの結果に基づいてタスクを実行またはスキップしたい場合がよくあります。たとえば、以前のタスクによってサービスがアップグレードされた後に、そのサービスを設定したい場合などです。登録された変数に基づいて条件分岐を作成するには、次のようにします。

en: Register the outcome of the earlier task as a variable.
ja: 以前のタスクの結果を変数として登録します。

en: Create a conditional test based on the registered variable.
ja: 登録した変数に基づいて条件分岐テストを作成します。

en: You create the name of the registered variable using the ``register`` keyword. A registered variable always contains the status of the task that created it as well as any output that task generated. You can use registered variables in templates and action lines as well as in conditional ``when`` statements. You can access the string contents of the registered variable using ``variable.stdout``. For example::
ja: 登録された変数の名前は、``register`` キーワードを使用して作成します。登録された変数には、そのキーワードを作成したタスクのステータスと、そのタスクが生成した出力が常に含まれています。登録された変数は、テンプレートやアクション行、および条件付きの ``when`` 文で使用できます。登録された変数の文字列内容にアクセスするには、``variable.stdout`` を使用します。以下に例を示します。

en: You can use registered results in the loop of a task if the variable is a list. If the variable is not a list, you can convert it into a list, with either ``stdout_lines`` or with ``variable.stdout.split()``. You can also split the lines by other fields::
ja: 登録された結果は、変数がリストの場合、タスクのループ内で使用できます。変数がリストでない場合は、``stdout_lines`` または``variable.stdout.split()`` でリストに変換できます。また、他のフィールドで行を分割することもできます。

en: The string content of a registered variable can be empty. If you want to run another task only on hosts where the stdout of your registered variable is empty, check the registered variable's string contents for emptiness:
ja: 登録された変数の文字列内容は空になることがあります。登録された変数の標準出力が空のホストでのみ別のタスクを実行したい場合は、登録された変数の文字列内容が空であるかどうかをチェックします。

en: Ansible always registers something in a registered variable for every host, even on hosts where a task fails or Ansible skips a task because a condition is not met. To run a follow-up task on these hosts, query the registered variable for ``is skipped`` (not for "undefined" or "default"). See :ref:`registered_variables` for more information. Here are sample conditionals based on the success or failure of a task. Remember to ignore errors if you want Ansible to continue executing on a host when a failure occurs:
ja: タスクが失敗したホストや、条件が満たされずに Ansible がタスクをスキップしたホストであっても、Ansible は常にすべてのホストの登録変数に何かを登録します。これらのホストでフォローアップタスクを実行するには、登録済みの変数に ``is skipped`` を照会します (「undefined」や「default」ではありません)。詳細は、「:ref:`registered_variables`」を参照してください。以下は、タスクの成功または失敗に基づく条件分岐のサンプルです。失敗したときにホスト上で Ansible の実行を継続させたい場合は、エラーを無視することを忘れないでください。

en: Older versions of Ansible used ``success`` and ``fail``, but ``succeeded`` and ``failed`` use the correct tense. All of these options are now valid.
ja: 古いバージョンの Ansible では、``success`` および ``fail`` が使用されていましたが、``succeeded`` および ``failed`` は正しい時制を使用します。このオプションはすべて有効になりました。

en: Conditionals based on variables
ja: 変数に基づく条件分岐

en: You can also create conditionals based on variables defined in the playbooks or inventory. Because conditionals require boolean input (a test must evaluate as True to trigger the condition), you must apply the ``| bool`` filter to non boolean variables, such as string variables with content like 'yes', 'on', '1', or 'true'. You can define variables like this:
ja: また、Playbook やインベントリーで定義された変数に基づいて、条件分岐を作成することもできます。条件分岐にはブール値の入力が必要なため (条件を成立させるためには、テストが True と評価されなければなりません)、「yes」、「on」、「1」、「true」などの内容を持つ文字列変数など、ブール値以外の変数には、``| bool`` フィルターを適用する必要があります。変数は次のように定義できます。

en: With the variables above, Ansible would run one of these tasks and skip the other:
ja: 上記の変数を使用すると、Ansible はこれらのタスクのいずれかを実行し、他のタスクを省略します。

en: If a required variable has not been set, you can skip or fail using Jinja2's `defined` test. For example:
ja: 必要な変数が設定されていない場合は、省略するか、Jinja2 の `定義済み` テストを使用して失敗します。以下に例を示します。

en: This is especially useful in combination with the conditional import of vars files (see below). As the examples show, you do not need to use `{{ }}` to use variables inside conditionals, as these are already implied.
ja: これは、変数ファイルの条件分岐インポートとの組み合わせで特に有効です (以下参照)。これらの例が示すように、条件分岐の中で変数を使用するために `{{ }}` を使用する必要はありません。それらはすでに暗示されているためです。

en: Using conditionals in loops
ja: ループでの条件分岐の使用

en: If you combine a ``when`` statement with a :ref:`loop <playbooks_loops>`, Ansible processes the condition separately for each item. This is by design, so you can execute the task on some items in the loop and skip it on other items. For example:
ja: ``when`` 文と :ref:`loop <playbooks_loops>` を組み合わせた場合、Ansible は各アイテムに対して個別に条件を処理します。これは意図的なもので、ループ内の一部のアイテムでタスクを実行し、他のアイテムではスキップすることができます。以下に例を示します。

en: If you need to skip the whole task when the loop variable is undefined, use the `|default` filter to provide an empty iterator. For example, when looping over a list:
ja: ループ変数が未定義のときにタスク全体を省略する必要がある場合は、`|default` フィルターを使用して空のイテレーターを指定します。たとえば、リストをループする場合は、以下を行います。

en: You can do the same thing when looping over a dict:
ja: 同じことが、ディクショナリーをループするときにもできます。

en: Loading custom facts
ja: カスタムファクトの読み込み中

en: You can provide your own facts, as described in :ref:`developing_modules`.  To run them, just make a call to your own custom fact gathering module at the top of your list of tasks, and variables returned there will be accessible to future tasks:
ja: :ref:`developing_modules` で説明しているように、独自のファクトを提供することができます。それらを実行するには、タスクリストの先頭にある独自のカスタムファクト収集モジュールを呼び出すだけで、そこから返された変数は将来のタスクにアクセスできるようになります。

en: Conditionals with re-use
ja: 再利用による条件分岐

en: You can use conditionals with re-usable tasks files, playbooks, or roles. Ansible executes these conditional statements differently for dynamic re-use (includes) and for static re-use (imports). See :ref:`playbooks_reuse` for more information on re-use in Ansible.
ja: 条件分岐は、再利用可能なタスクファイル、Playbook、またはロールで使用できます。Ansible はこれらの条件文を、動的再利用 (インクルード) および静的再利用 (インポート) で異なる方法で実行します。Ansible での再利用の詳細は、「:ref:`playbooks_reuse`」を参照してください。

en: Conditionals with imports
ja: インポートのある条件分岐

en: When you add a conditional to an import statement, Ansible applies the condition to all tasks within the imported file. This behavior is the equivalent of :ref:`tag_inheritance`. Ansible applies the condition to every task, and evaluates each task separately. For example, you might have a playbook called ``main.yml`` and a tasks file called ``other_tasks.yml``::
ja: インポートステートメントに条件分岐を追加すると、Ansible はインポートされたファイル内のすべてのタスクにその条件を適用します。この動作は、:ref:`tag_inheritance` と同等です。Ansible は、すべてのタスクに条件を適用し、各タスクを個別に評価します。たとえば、``main.yml`` という Playbookと、``other_tasks.yml`` というタスクファイルがあるとします。

en: Ansible expands this at execution time to the equivalent of::
ja: Ansible は、実行時にこれを以下に相当するものに拡張します。

en: Thus if ``x`` is initially undefined, the ``debug`` task will be skipped. If this is not the behavior you want, use an ``include_*`` statement to apply a condition only to that statement itself.
ja: したがって、``x`` が最初に未定義であれば、``debug`` のタスクはスキップされます。このような動作を望まない場合は、``include_*`` 文を使用して、その文自体にのみ条件を適用します。

en: You can apply conditions to ``import_playbook`` as well as to the other ``import_*`` statements. When you use this approach, Ansible returns a 'skipped' message for every task on every host that does not match the criteria, creating repetitive output. In many cases the :ref:`group_by module <group_by_module>` can be a more streamlined way to accomplish the same objective; see :ref:`os_variance`.
ja: ``import_playbook`` には、他の ``import_*`` 文と同様に条件を適用できます。この方法を使用すると、Ansible は基準に一致しないすべてのホスト上のすべてのタスクに対して「skipped」メッセージを返し、反復的な出力を作成します。多くの場合、:ref:`group_by モジュール <group_by_module>` は、同じ目的を達成するためのより合理的な方法となります。「:ref:`os_variance`」を参照してください。

en: Conditionals with includes
ja: includes を持つ条件分岐

en: When you use a conditional on an ``include_*`` statement, the condition is applied only to the include task itself and not to any other tasks within the included file(s). To contrast with the example used for conditionals on imports above, look at the same playbook and tasks file, but using an include instead of an import::
ja: ``include_*`` 文に条件分岐を使用すると、その条件はインクルードタスク自体にのみ適用され、インクルードファイル内の他のタスクには適用されません。上記のインポートに対する条件分岐の例と対比するために、同じ Playbook とタスクファイルを見てください。ただし、インポートの代わりにインクルードを使用しています。

en: By using ``include_tasks`` instead of ``import_tasks``, both tasks from ``other_tasks.yml`` will be executed as expected. For more information on the differences between ``include`` v ``import`` see :ref:`playbooks_reuse`.
ja: ``import_tasks`` の代わりに ``include_tasks`` を使用すると、``other_tasks.yml`` からの両方のタスクが想定どおりに実行されます。``include`` と ``import`` の相違点は、「:ref:`playbooks_reuse`」を参照してください。

en: Conditionals with roles
ja: ロールを含む条件分岐

en: There are three ways to apply conditions to roles:
ja: 状態をロールに適用する方法は 3 つあります。

en: Add the same condition or conditions to all tasks in the role by placing your ``when`` statement under the ``roles`` keyword. See the example in this section.
ja: ``when`` 文を ``roles`` キーワードの下に置くことで、ロール内のすべてのタスクに同じ条件を追加します。このセクションの例を参照してください。

en: Add the same condition or conditions to all tasks in the role by placing your ``when`` statement on a static ``import_role`` in your playbook.
ja: Playbook の静的 ``import_role`` に ``when`` 文を配置して、ロール内のすべてのタスクに同じ条件を追加します。

en: Add a condition or conditions to individual tasks or blocks within the role itself. This is the only approach that allows you to select or skip some tasks within the role based on your ``when`` statement. To select or skip tasks within the role, you must have conditions set on individual tasks or blocks, use the dynamic ``include_role`` in your playbook, and add the condition or conditions to the include. When you use this approach, Ansible applies the condition to the include itself plus any tasks in the role that also have that ``when`` statement.
ja: ロール自体の中の個々のタスクまたはブロックに条件を追加します。これは、``when`` 文に基づいてロール内の一部のタスクを選択またはスキップすることができる唯一の方法です。ロール内のタスクを選択またはスキップするには、個々のタスクまたはブロックに条件を設定し、Playbook で動的 ``include_role`` を使用し、条件をインクルードに追加する必要があります。この方法を使用すると、Ansible は条件をインクルード自体に加えて、``when`` の文を持つロール内のすべてのタスクに適用します。

en: When you incorporate a role in your playbook statically with the ``roles`` keyword, Ansible adds the conditions you define to all the tasks in the role. For example:
ja: ``roles`` キーワードを使用して Playbook にロールを静的に組み込むと、Ansible は定義した条件をロール内のすべてのタスクに追加します。たとえば、以下のようになります。

en: Selecting variables, files, or templates based on facts
ja: ファクトに基づいた変数、ファイル、またはテンプレートの選択

en: Sometimes the facts about a host determine the values you want to use for certain variables or even the file or template you want to select for that host. For example, the names of packages are different on CentOS and on Debian. The configuration files for common services are also different on different OS flavors and versions. To load different variables file, templates, or other files based on a fact about the hosts:
ja: ホストに関するファクトによって、特定の変数に使用する値や、そのホスト用に選択するファイルやテンプレートが決定することがあります。たとえば、パッケージの名前は CentOS と Debian では異なります。また、一般的なサービスの設定ファイルも、OS のフレーバーやバージョンごとに異なります。ホストに関するファクトに基づいて、異なる変数ファイルやテンプレートなどを読み込むには、以下を行います。

en: name your vars files, templates, or files to match the Ansible fact that differentiates them
ja: 変数ファイル、テンプレート、またはファイルを区別する Ansible ファクトに合わせて名前を付ける

en: select the correct vars file, template, or file for each host with a variable based on that Ansible fact
ja: Ansible ファクトに基づいて変数を使用して、各ホストの正しい変数ファイル、テンプレート、またはファイルを選択します。

en: Ansible separates variables from tasks, keeping your playbooks from turning into arbitrary code with nested conditionals. This approach results in more streamlined and auditable configuration rules because there are fewer decision points to track.
ja: Ansible は、変数とタスクを分離することで、Playbook がネストされた条件分岐による任意のコードにならないようにしています。このアプローチでは、追跡すべき決定ポイントが少なくなるため、より合理的で監査可能な設定ルールになります。

en: Selecting variables files based on facts
ja: ファクトに基づく変数ファイルの選択

en: You can create a playbook that works on multiple platforms and OS versions with a minimum of syntax by placing your variable values in vars files and conditionally importing them. If you want to install Apache on some CentOS and some Debian servers, create variables files with YAML keys and values. For example::
ja: 変数の値を vars ファイルに置き、条件付きでインポートすることで、最小限の構文で複数のプラットフォームや OS バージョンで動作する Playbook を作成することができます。一部の CentOS と一部の Debian サーバーに Apache をインストールする場合は、YAML のキーと値で変数ファイルを作成します。以下に例を示します。

en: Then import those variables files based on the facts you gather on the hosts in your playbook::
ja: 次に、Playbook のホストに収集するファクトに基づいて、これらの変数ファイルをインポートします。

en: Ansible gathers facts on the hosts in the webservers group, then interpolates the variable "ansible_facts['os_family']" into a list of filenames. If you have hosts with Red Hat operating systems (CentOS, for example), Ansible looks for 'vars/RedHat.yml'. If that file does not exist, Ansible attempts to load 'vars/os_defaults.yml'. For Debian hosts, Ansible first looks for 'vars/Debian.yml', before falling back on 'vars/os_defaults.yml'. If no files in the list are found, Ansible raises an error.
ja: Ansible は webservers グループに属するホストのファクトを収集し、変数「ansible_facts['os_family']」をファイル名のリストに補間します。Red Hat オペレーティングシステムを搭載したホスト (CentOS など) がある場合、Ansible は「vars/RedHat.yml」を探します。このファイルが存在しない場合、Ansibleは「vars/os_defaults.yml」の読み込みを試みます。Debian ホストの場合、Ansible はまず「vars/Debian.yml」を探し、その後で「vars/os_defaults.yml」にフォールバックします。リスト内のファイルが見つからない場合は、Ansible がエラーを出力します。

en: Selecting files and templates based on facts
ja: ファクトに基づくファイルとテンプレートの選択

en: You can use the same approach when different OS flavors or versions require different configuration files or templates. Select the appropriate file or template based on the variables assigned to each host. This approach is often much cleaner than putting a lot of conditionals into a single template to cover multiple OS or package versions.
ja: OS のフレーバーやバージョンによって、設定ファイルやテンプレートが異なる場合も同様の方法で対応できます。各ホストに割り当てられた変数に基づいて、適切なファイルやテンプレートを選択します。この方法は、複数の OS やパッケージのバージョンに対応するために 1 つのテンプレートに多くの条件分岐を入れるよりも、はるかにすっきりすることが多いです。

en: For example, you can template out a configuration file that is very different between, say, CentOS and Debian::
ja: 例えば、CentOS と Debian の間で大きく異なる設定ファイルをテンプレート化することができます。

en: Commonly-used facts
ja: 一般的に使用されるファクト

en: The following Ansible facts are frequently used in conditionals.
ja: 以下の Ansible ファクトは、条件分岐で頻繁に使用されます。

en: Possible values (sample, not complete list)::
ja: 使用できる値 (完全リストではなく一部です):

en: The major version of the operating system. For example, the value is `16` for Ubuntu 16.04.
ja: オペレーティングシステムのメジャーバージョンです。たとえば、Ubuntu 16.04 の場合は `16` となります。

en: Tips and tricks for playbooks
ja: Playbook のヒントと裏技

en: Debugging tasks
ja: タスクのデバッグ

en: Ansible offers a task debugger so you can fix errors during execution instead of editing your playbook and running it again to see if your change worked. You have access to all of the features of the debugger in the context of the task. You can check or set the value of variables, update module arguments, and re-run the task with the new variables and arguments. The debugger lets you resolve the cause of the failure and continue with playbook execution.
ja: Ansible にはタスクデバッガーがあり、変更が成功したかどうかを確認するために Playbook を編集して再度実行するのではなく、実行中にエラーを修正することができます。タスクのコンテキスト内で、デバッガーのすべての機能にアクセスできます。変数の値をチェックしたり設定したり、モジュールの引数を更新したり、新しい変数や引数を使用してタスクを再実行したりできます。デバッガーは、失敗の原因を解決し、Playbook の実行を続行することができます。

en: Enabling the debugger
ja: デバッガーの有効化

en: The debugger is not enabled by default. If you want to invoke the debugger during playbook execution, you must enable it first.
ja: デバッガーはデフォルトでは有効になっていません。Playbook の実行中にデバッガーを呼び出す場合は、最初に有効にする必要があります。

en: Use one of these three methods to enable the debugger:
ja: 以下の 3 つの方法のいずれかを使用してデバッガーを有効にします。

en: with the debugger keyword
ja: デバッガーキーワードの使用

en: in configuration or an environment variable, or
ja: 設定または環境変数で

en: as a strategy
ja: ストラテジーとして

en: Enabling the debugger with the ``debugger`` keyword
ja: ``debugger`` キーワードでデバッガーを有効にする

en: You can use the ``debugger`` keyword to enable (or disable) the debugger for a specific play, role, block, or task. This option is especially useful when developing or extending playbooks, plays, and roles. You can enable the debugger on new or updated tasks. If they fail, you can fix the errors efficiently. The ``debugger`` keyword accepts five values:
ja: ``debugger`` キーワードを使用すると、特定のプレイ、ロール、ブロック、またはタスクに対してデバッガーを有効 (または無効) にすることができます。このオプションは、Playbook、プレイ、およびロールを開発または拡張する際に特に役立ちます。新規または更新されたタスクでデバッガーを有効にすることができます。失敗しても、効率的にエラーを修正することができます。``debugger`` キーワードは 5 つの値を受け入れます。

en: Value
ja: 値

en: Result
ja: 結果

en: Always invoke the debugger, regardless of the outcome
ja: 結果に関係なく、常にデバッガーを呼び出します。

en: Never invoke the debugger, regardless of the outcome
ja: 結果に関係なく、デバッガーを呼び出しません。

en: Only invoke the debugger if a task fails
ja: タスクが失敗した場合に限りデバッガーを呼び出します。

en: Only invoke the debugger if a host is unreachable
ja: ホストが到達できない場合に限りデバッガーを呼び出します。

en: Only invoke the debugger if the task is skipped
ja: タスクがスキップされた場合に限りデバッガーを呼び出します。

en: When you use the ``debugger`` keyword, the value you specify overrides any global configuration to enable or disable the debugger. If you define ``debugger`` at multiple levels, such as in a role and in a task, Ansible honors the most granular definition. The definition at the play or role level applies to all blocks and tasks within that play or role, unless they specify a different value. The definition at the block level overrides the definition at the play or role level, and applies to all tasks within that block, unless they specify a different value. The definition at the task level always applies to the task; it overrides the definitions at the block, play, or role level.
ja: ``debugger`` キーワードを使用すると、指定した値が、デバッガ―を有効または無効にするグローバル構成よりも優先されます。``debugger`` をロールやタスクなどの複数のレベルで定義した場合、Ansible は最も詳細な定義を尊重します。プレイまたはロールのレベルでの定義は、異なる値を指定しない限り、そのプレイまたはロール内のすべてのブロックおよびタスクに適用されます。ブロックレベルの定義は、プレイまたはロールレベルの定義よりも優先され、異なる値が指定されていない限り、そのブロック内のすべてのタスクに適用されます。タスクレベルでの定義は、常にタスクに適用され、ブロック、プレイ、またはロールレベルでの定義よりも優先されます。

en: Examples of using the ``debugger`` keyword
ja: ``debugger`` キーワードの使用例

en: Example of setting the ``debugger`` keyword on a task:
ja: タスクに ``debugger`` キーワードを設定する例:

en: Example of setting the ``debugger`` keyword on a play:
ja: プレイに ``debugger`` キーワードを設定する例:

en: Example of setting the ``debugger`` keyword at multiple levels:
ja: 複数のレベルで ``debugger`` キーワードを設定する例:

en: In this example, the debugger is set to ``never`` at the play level and to ``on_failed`` at the task level. If the task fails, Ansible invokes the debugger, because the definition on the task overrides the definition on its parent play.
ja: この例では、デバッガーは、プレイレベルでは ``never`` に、タスクレベルでは ``on_failed`` に設定されています。タスクが失敗した場合、タスクの定義が親プレイの定義を上書きするため、Ansible はデバッガーを起動します。

en: Enabling the debugger in configuration or an environment variable
ja: 設定または環境変数でのデバッガーの有効化

en: You can enable the task debugger globally with a setting in ansible.cfg or with an environment variable. The only options are ``True`` or ``False``. If you set the configuration option or environment variable to ``True``, Ansible runs the debugger on failed tasks by default.
ja: タスクデバッガーをグローバルに有効にするには、ansible.cfg 内の設定または環境変数を使用します。オプションは ``True`` または ``False`` のみです。設定オプションまたは環境変数を ``True`` に設定した場合、Ansible はデフォルトで失敗したタスクに対してデバッガーを実行します。

en: To enable the task debugger from ansible.cfg, add this setting to the defaults section::
ja: ansible.cfg からタスクデバッガーを有効にするには、以下の設定を defaults セクションに追加します。

en: To enable the task debugger with an environment variable, pass the variable when you run your playbook::
ja: 環境変数でタスクデバッガーを有効にするには、Playbook の実行時に変数を渡します。

en: When you enable the debugger globally, every failed task invokes the debugger, unless the role, play, block, or task explicity disables the debugger. If you need more granular control over what conditions trigger the debugger, use the ``debugger`` keyword.
ja: グローバルにデバッガを有効にすると、ロール、プレイ、ブロック、またはタスクが明示的にデバッガ―を無効にしていない限り、失敗したタスクはすべてデバッガ―を起動します。どのような条件でデバッガーが起動するかをより詳細に制御する必要がある場合は、``debugger`` キーワードを使用します。

en: Enabling the debugger as a strategy
ja: ストラテジーとしてのデバッガーの有効化

en: If you are running legacy playbooks or roles, you may see the debugger enabled as a :ref:`strategy <strategy_plugins>`. You can do this at the play level, in ansible.cfg, or with the environment variable ``ANSIBLE_STRATEGY=debug``. For example:
ja: レガシーの Playbook やロールを実行している場合は、:ref:`strategy <strategy_plugins>` としてデバッガーが有効になっていることがあります。この設定は、プレイレベル、ansible.cfg、または環境変数 ``ANSIBLE_STRATEGY=debug`` で行うことができます。以下に例を示します。

en: Or in ansible.cfg::
ja: または ansible.cfg で以下を行います。

en: This backwards-compatible method, which matches Ansible versions before 2.5, may be removed in a future release.
ja: この後方互換性のある方法は、Ansible の 2.5 以前のバージョンに対応していますが、将来のリリースでは削除される可能性があります。

en: Resolving errors in the debugger
ja: デバッガーでエラーの解決

en: After Ansible invokes the debugger, you can use the seven :ref:`debugger commands <available_commands>` to resolve the error that Ansible encountered. Consider this example playbook, which defines the ``var1`` variable but uses the undefined ``wrong_var`` variable in a task by mistake.
ja: Ansible がデバッガーを起動した後、7 つの :ref:`debugger コマンド <available_commands>` を使用して、Ansibleが遭遇したエラーを解決することができます。この Playbook の例では ``var1`` 変数を定義していますが、未定義の``wrong_var`` 変数を誤ってタスクで使用します。

en: If you run this playbook, Ansible invokes the debugger when the task fails. From the debug prompt, you can change the module arguments or the variables and run the task again.
ja: この Playbook を実行すると、Ansible はタスクの失敗時にデバッガーを呼び出します。デバッグプロンプトから、モジュール引数または変数を変更して、タスクを再度実行できます。

en: Changing the task arguments in the debugger to use ``var1`` instead of ``wrong_var`` makes the task run successfully.
ja: デバッガでタスクの引数 ``wrong_var`` の代わりに``var1`` を使うように変更すると、タスクが正常に実行されます。

en: Available debug commands
ja: 利用可能なデバッグコマンド

en: You can use these seven commands at the debug prompt:
ja: これらの 7 つのコマンドは、デバッグプロンプトで使用できます。

en: Command
ja: コマンド

en: Shortcut
ja: ショートカット

en: Action
ja: アクション

en: print
ja: 印刷

en: Print information about the task
ja: タスクに関する情報を出力する

en: no shortcut
ja: ショートカットなし

en: Update module arguments
ja: モジュール引数を更新する

en: Update task variables (you must ``update_task`` next)
ja: タスク変数を更新する (次回 ``update_task`` する必要があります)

en: Recreate a task with updated task variables
ja: 更新されたタスク変数でタスクを再作成する

en: Run the task again
ja: タスクを再度実行する

en: continue
ja: 続行

en: Continue executing, starting with the next task
ja: 実行を継続する (次のタスクから開始)

en: quit
ja: 終了

en: Quit the debugger
ja: デバッガーを終了する

en: For more details, see the individual descriptions and examples below.
ja: 詳細は、以下の個別の説明および例を参照してください。

en: Print command
ja: コマンドを出力する

en: ``print *task/task.args/task_vars/host/result*`` prints information about the task::
ja: ``print *task/task.args/task_vars/host/result*`` は、タスクに関する情報を出力します。

en: Update args command
ja: args コマンドを更新する

en: ``task.args[*key*] = *value*`` updates a module argument. This sample playbook has an invalid package name::
ja: ``task.args[*key*] = *value*`` モジュール引数を更新します。このサンプル Playbook には無効なパッケージ名があります。

en: When you run the playbook, the invalid package name triggers an error, and Ansible invokes the debugger. You can fix the package name by viewing, then updating the module argument::
ja: Playbook を実行すると、パッケージ名が無効であるためにエラーが発生し、Ansible がデバッガーを起動します。パッケージ名を修正するには、モジュールの引数を表示してから更新します。

en: After you update the module argument, use ``redo`` to run the task again with the new args.
ja: モジュール引数を更新したら、``redo`` を使用して、新しい引数でタスクを再度実行します。

en: Update vars command
ja: vars コマンドの更新

en: ``task_vars[*key*] = *value*`` updates the ``task_vars``. You could fix the playbook above by viewing, then updating the task variables instead of the module args::
ja: ``task_vars[*key*] = *value*`` は、``task_vars`` を更新します。モジュール引数ではなくタスク変数を表示してから更新して、上記の Playbook を修正できます。

en: After you update the task variables, you must use ``update_task`` to load the new variables before using ``redo`` to run the task again.
ja: タスク変数を更新したら、``redo`` を使用してタスクを再実行する前に、``update_task`` を使用して新しい変数を読み込む必要があります。

en: In 2.5 this was updated from ``vars`` to ``task_vars`` to avoid conflicts with the ``vars()`` python function.
ja: これは、python 関数 ``vars()`` と競合しないように、2.5 で ``vars`` から ``task_vars`` に更新されました。

en: Update task command
ja: task コマンドの更新

en: ``u`` or ``update_task`` recreates the task from the original task data structure and templates with updated task variables. See the entry :ref:`update_vars_command` for an example of use.
ja: ``u`` または ``update_task`` は、更新されたタスク変数を持つ元のタスクデータ構造とテンプレートからタスクを再作成します。使用例は、エントリー:ref:`update_vars_command` を参照してください。

en: Redo command
ja: コマンドのやり直し

en: ``r`` or ``redo`` runs the task again.
ja: ``r`` または ``redo`` はタスクを再実行します。

en: Continue command
ja: コマンドの続行

en: ``c`` or ``continue`` continues executing, starting with the next task.
ja: ``c`` または ``continue`` は、次のタスクから開始して実行を継続します。

en: Quit command
ja: Quit コマンド

en: ``q`` or ``quit`` quits the debugger. The playbook execution is aborted.
ja: ``q`` または ``quit`` はデバッガーを終了します。Playbook の実行は中止します。

en: How the debugger interacts with the free strategy
ja: デバッガーがフリーストラテジーとどのように相互作用するか

en: With the default ``linear`` strategy enabled, Ansible halts execution while the debugger is active, and runs the debugged task immediately after you enter the ``redo`` command. With the ``free`` strategy enabled, however, Ansible does not wait for all hosts, and may queue later tasks on one host before a task fails on another host. With the ``free`` strategy, Ansible does not queue or execute any tasks while the debugger is active. However, all queued tasks remain in the queue and run as soon as you exit the debugger. If you use ``redo`` to reschedule a task from the debugger, other queued tasks may execute before your rescheduled task. For more information about strategies, see :ref:`playbooks_strategies`.
ja: デフォルトの ``linear`` 戦略を有効にすると、Ansible はデバッガ―がアクティブな間は実行を停止し、``redo`` コマンドを入力した直後にデバッグされたタスクを実行します。しかし、``free`` ストラテジーを有効にすると、Ansible はすべてのホストを待たずに、別のホストでタスクが失敗する前に、あるホストで後のタスクをキューに入れることがあります。``free`` 戦略を使用すると、デバッガーがアクティブな間、Ansible は、タスクの照会や実行を行いません。ただし、キューに入れられたタスクはすべてキューに残り、デバッガーを終了するとすぐに実行されます。``redo`` を使用してデバッガーからタスクを再スケジュールすると、再スケジュールされたタスクの前にキューに入れられた他のタスクが実行する場合があります。ストラテジーの詳細については「:ref:`playbooks_strategies`」を参照してください。

en: Running playbooks while debugging or testing
ja: デバッグ時またはテスト時の Playbook の実行

en: Controlling where tasks run: delegation and local actions
ja: タスクの実行場所の制御: 委譲およびローカルアクション

en: By default Ansible gathers facts and executes all tasks on the machines that match the ``hosts`` line of your playbook. This page shows you how to delegate tasks to a different machine or group, delegate facts to specific machines or groups, or run an entire playbook locally. Using these approaches, you can manage inter-related environments precisely and efficiently. For example, when updating your webservers, you might need to remove them from a load-balanced pool temporarily. You cannot perform this task on the webservers themselves. By delegating the task to localhost, you keep all the tasks within the same play.
ja: デフォルトでは、Ansible はファクトを収集し、Playbook の ``hosts`` 行に一致するマシン上ですべてのタスクを実行します。このページでは、タスクを別のマシンやグループに委譲したり、ファクトを特定のマシンやグループに委譲したり、Playbook 全体をローカルで実行する方法を紹介します。これらの方法を用いることで、相互に関連する環境を正確かつ効率的に管理することができます。たとえば、Web サーバーを更新する際に、負荷分散したプールから一時的に Web サーバーを削除しないといけない場合があります。このタスクは、Web サーバー自身では実行できません。このタスクを localhost に委譲することで、すべてのタスクを同じプレイに収めることができます。

en: Tasks that cannot be delegated
ja: 委譲できないタスク

en: Some tasks always execute on the controller. These tasks, including ``include``, ``add_host``, and ``debug``, cannot be delegated.
ja: 一部のタスクは常にコントローラーで実行します。これらのタスクには、``include``、``add_host``、および ``debug`` を含むタスクを委譲できません。

en: Delegating tasks
ja: タスクの委譲

en: If you want to perform a task on one host with reference to other hosts, use the ``delegate_to`` keyword on a task. This is ideal for managing nodes in a load balanced pool or for controlling outage windows. You can use delegation with the :ref:`serial <rolling_update_batch_size>` keyword to control the number of hosts executing at one time::
ja: あるホストで他のホストを参照しながらタスクを実行したい場合は、タスクに ``delegate_to`` キーワードを使用します。これは、負荷分散されたプールのノードを管理したり、障害発生時のウィンドウを制御するのに最適です。:ref:`serial <rolling_update_batch_size>` キーワードで委譲を使用すると、一度に実行するホストの数を制御することができます。

en: The first and third tasks in this play run on 127.0.0.1, which is the machine running Ansible. There is also a shorthand syntax that you can use on a per-task basis: ``local_action``. Here is the same playbook as above, but using the shorthand syntax for delegating to 127.0.0.1::
ja: ここでは、1 番目と 3 番目のタスクを 127.0.0.1 で実行していますが、これは Ansible を実行しているマシンです。また、タスクごとに使用できる簡略化された構文があります (``local_action``)。以下は、上記と同じ Playbook ですが、127.0.0.1 に委譲するための短縮構文を使用します。

en: You can use a local action to call 'rsync' to recursively copy files to the managed servers::
ja: ローカルアクションを使用して「rsync」を呼び出し、管理対象のサーバーにファイルを再帰的にコピーすることができます。

en: Note that you must have passphrase-less SSH keys or an ssh-agent configured for this to work, otherwise rsync asks for a passphrase.
ja: これが機能するためには、パスフレーズなしの SSH 鍵または ssh-agent が設定されていなければならないことに注意してください。そうでなければ、rsync はパスフレーズを要求します。

en: To specify more arguments, use the following syntax::
ja: 引数をさらに指定する必要がある場合は、以下の構文を使用できます。

en: The `ansible_host` variable reflects the host a task is delegated to.
ja: `ansible_host` 変数は、タスクが委譲されるホストを反映します。

en: Delegating facts
ja: ファクトの委譲

en: Delegating Ansible tasks is like delegating tasks in the real world - your groceries belong to you, even if someone else delivers them to your home. Similarly, any facts gathered by a delegated task are assigned by default to the `inventory_hostname` (the current host), not to the host which produced the facts (the delegated to host). To assign gathered facts to the delegated host instead of the current host, set ``delegate_facts`` to ``true``::
ja: Ansible のタスクを委譲することは、現実世界でタスクを委譲することと同じです。たとえ他の誰かがあなたの家に食料品を届けたとしても、あなたの食料品はあなたのものです。同様に、委譲されたタスクによって収集されたファクトは、デフォルトでは、ファクトを生成したホスト (委譲されたホスト) ではなく、`inventory_hostname` (現在のホスト) に割り当てられます。集めたファクトを現在のホストではなく委譲されたホストに割り当てるには、``delegate_facts`` を ``true`` に設定します。

en: This task gathers facts for the machines in the dbservers group and assigns the facts to those machines, even though the play targets the app_servers group. This way you can lookup `hostvars['dbhost1']['ansible_default_ipv4']['address']` even though dbservers were not part of the play, or left out by using `--limit`.
ja: このタスクは、プレイが app_servers グループを対象としているにもかかわらず、dbservers グループのマシンのファクトを収集し、それらのマシンにファクトを割り当てます。このようにして、たとえ dbservers がプレイの一部でなくても、あるいは `--limit` を使用して除外されていても、`hostvars['dbhost1']['ansible_default_ipv4']['address']` を調べることができます。

en: Local playbooks
ja: ローカルの Playbook

en: It may be useful to use a playbook locally on a remote host, rather than by connecting over SSH.  This can be useful for assuring the configuration of a system by putting a playbook in a crontab.  This may also be used to run a playbook inside an OS installer, such as an Anaconda kickstart.
ja: SSH で接続するのではなく、リモートホスト上でローカルに Playbook を使用することが便利な場合があります。これは、crontab に Playbook を置くことで、システムの構成を保証するのに役立ちます。また、Anaconda のキックスタートなど、OS インストーラー内で Playbook を実行する場合にも使用できます。

en: To run an entire playbook locally, just set the ``hosts:`` line to ``hosts: 127.0.0.1`` and then run the playbook like so::
ja: Playbook 全体をローカルで実行するには、``hosts:`` 行を ``hosts: 127.0.0.1`` に設定し、次のように Playbook を実行します。

en: Alternatively, a local connection can be used in a single playbook play, even if other plays in the playbook use the default remote connection type::
ja: また、Playbook 内の他のプレイがデフォルトのリモート接続タイプを使用していても、1 つの Playbook のプレイでローカル接続を使用することもできます。

en: If you set the connection to local and there is no ansible_python_interpreter set, modules will run under /usr/bin/python and not under {{ ansible_playbook_python }}. Be sure to set ansible_python_interpreter: "{{ ansible_playbook_python }}" in host_vars/localhost.yml, for example. You can avoid this issue by using ``local_action`` or ``delegate_to: localhost`` instead.
ja: 接続先をローカルに設定し、ansible_python_interpreter が設定されていない場合、モジュールは /usr/bin/python で実行し、{{ ansible_playbook_python }} では実行されません。ansible_python_interpreter を必ず設定してください (host_vars/localhost.yml の「{{ ansible_playbook_python }}」など)。代わりに ``local_action`` または ``delegate_to: localhost`` を使用することで、この問題を回避できます。

en: More ways to control how and where Ansible executes
ja: Ansible の実行方法および場所を制御する方法

en: Many examples of full-stack deployments
ja: フルスタックデプロイメントの例が多数あります。

en: Setting the remote environment
ja: リモート環境の設定

en: You can use the ``environment`` keyword at the play, block, or task level to set an environment variable for an action on a remote host. With this keyword, you can enable using a proxy for a task that does http requests, set the required environment variables for language-specific version managers, and more.
ja: プレイ、ブロック、またはタスクのレベルで ``environment`` キーワードを使用して、リモートホスト上のアクションに環境変数を設定することができます。このキーワードを使用すると、http リクエストを行うタスクでプロキシーの使用を有効にしたり、言語固有のバージョンマネージャーに必要な環境変数を設定したりすることができます。

en: When you set a value with ``environment:`` at the play or block level, it is available only to tasks within the play or block that are executed by the same user. The ``environment:`` keyword does not affect Ansible itself, Ansible configuration settings, the environment for other users, or the execution of other plugins like lookups and filters. Variables set with ``environment:`` do not automatically become Ansible facts, even when you set them at the play level. You must include an explicit ``gather_facts`` task in your playbook and set the ``environment`` keyword on that task to turn these values into Ansible facts.
ja: プレイまたはブロックレベルで ``environment:`` を使用して値を設定すると、同じユーザーによって実行されるプレイまたはブロック内のタスクでのみ使用できます。``environment:`` キーワードは、Ansible 自体、Ansible の構成設定、他のユーザーの環境、ルックアップやフィルターなどの他のプラグインの実行には影響しません。``environment:`` で設定した変数は、プレイレベルで設定しても、自動的に Ansible のファクトにはなりません。これらの値を Ansible のファクトにするには、Playbook に明示的な ``gather_facts`` タスクを含め、そのタスクに ``environment`` キーワードを設定する必要があります。

en: Setting the remote environment in a task
ja: タスクへのリモート環境の設定

en: You can set the environment directly at the task level::
ja: タスクレベルで環境を直接指定することもできます。

en: You can re-use environment settings by defining them as variables in your play and accessing them in a task as you would access any stored Ansible variable::
ja: 環境変数をプレイの変数として定義し、保存した Ansible 変数にアクセスするときにタスクからアクセスできることで、環境変数を再利用できます。

en: You can store environment settings for re-use in multiple playbooks by defining them in a group_vars file::
ja: 複数の Playbook に再使用する環境設定は、group_vars ファイルに定義することで保存できます。

en: You can set the remote environment at the play level::
ja: プレイレベルでリモート環境を設定できます。

en: These examples show proxy settings, but you can provide any number of settings this way.
ja: これらの例ではプロキシー設定を示していますが、この設定をいくつでも提供できます。

en: Working with language-specific version managers
ja: 言語固有のバージョンマネージャーの使用

en: Some language-specific version managers (such as rbenv and nvm) require you to set environment variables while these tools are in use. When using these tools manually, you usually source some environment variables from a script or from lines added to your shell configuration file. In Ansible, you can do this with the environment keyword at the play level::
ja: 言語固有のバージョンマネージャー (rbenv や nvmなど) の中には、これらのツールを使用する際に環境変数を設定する必要があります。これらのツールを手動で使用する場合、通常はスクリプトやシェル構成ファイルに追加した行から環境変数を設定します。Ansible では、プレイレベルで環境キーワードを使用してこれを行うことができます。

en: The example above uses ``ansible_env`` as part of the PATH. Basing variables on ``ansible_env`` is risky. Ansible populates ``ansible_env`` values by gathering facts, so the value of the variables depends on the remote_user or become_user Ansible used when gathering those facts. If you change remote_user/become_user the values in ``ansible-env`` may not be the ones you expect.
ja: 上の例では、``ansible_env`` を PATH の一部として使用しています。変数を ``ansible_env`` に基づかせるのはリスクがあります。Ansible はファクトを収集して ``ansible_env`` の値を生成するため、変数の値はファクトの収集時に Ansible が使用した remote_user や become_user に依存します。remote_user/become_user を変更した場合、``ansible-env`` の値は期待したものとは異なる可能性があります。

en: Environment variables are normally passed in clear text (shell plugin dependent) so they are not a recommended way of passing secrets to the module being executed.
ja: 環境変数は、通常、(シェルプラグインに依存する) クリアテキストに渡されます。したがって、実行するモジュールにシークレットを渡す方法は推奨されません。

en: You can also specify the environment at the task level::
ja: タスクレベルで環境を指定することもできます。

en: Error handling in playbooks
ja: Playbook でのエラー処理

en: When Ansible receives a non-zero return code from a command or a failure from a module, by default it stops executing on that host and continues on other hosts. However, in some circumstances you may want different behavior. Sometimes a non-zero return code indicates success. Sometimes you want a failure on one host to stop execution on all hosts. Ansible provides tools and settings to handle these situations and help you get the behavior, output, and reporting you want.
ja: Ansible は、コマンドからゼロ以外の戻りコードを受け取った場合や、モジュールから失敗を受け取った場合、デフォルトでは、そのホストでの実行を停止し、他のホストで継続します。しかし、状況によっては異なる動作をさせたい場合があります。ゼロ以外の戻りコードが成功を示す場合もあります。あるホストで失敗したら、すべてのホストで実行を停止させたい場合もあります。Ansible には、このような状況に対応するためのツールや設定が用意されており、必要な動作、出力、レポートを得ることができます。

en: Ignoring failed commands
ja: 失敗したコマンドの無視

en: By default Ansible stops executing tasks on a host when a task fails on that host. You can use ``ignore_errors`` to continue on in spite of the failure::
ja: デフォルトでは、Ansible は、ホストでタスクが失敗すると、ホストでタスクの実行を停止します。``ignore_errors`` を使用すると、障害が発生しても続行されます。

en: The ``ignore_errors`` directive only works when the task is able to run and returns a value of 'failed'. It does not make Ansible ignore undefined variable errors, connection failures, execution issues (for example, missing packages), or syntax errors.
ja: ``ignore_errors`` ディレクティブは、タスクが実行可能で、「failed」という値を返す場合にのみ機能します。未定義の変数のエラー、接続の失敗、実行時の問題 (パッケージの欠落など)、構文エラーなどを Ansible に無視させるものではありません。

en: Ignoring unreachable host errors
ja: 到達不能なホストエラーを無視

en: You can ignore a task failure due to the host instance being 'UNREACHABLE' with the ``ignore_unreachable`` keyword. Ansible ignores the task errors, but continues to execute future tasks against the unreachable host. For example, at the task level::
ja: ``ignore_unreachable`` キーワードで、ホストインスタンスが「UNREACHABLE」であることによるタスクの失敗を無視することができます。Ansible はタスクのエラーを無視しますが、到達不可能なホストに対して今後のタスクを実行し続けます。たとえば、タスクレベルでは以下のようになります。

en: And at the playbook level::
ja: また、Playbook レベルでは以下を行います。

en: Resetting unreachable hosts
ja: 到達できないホストのリセット

en: If Ansible cannot connect to a host, it marks that host as 'UNREACHABLE' and removes it from the list of active hosts for the run. You can use `meta: clear_host_errors` to reactivate all hosts, so subsequent tasks can try to reach them again.
ja: Ansible はホストに接続できない場合、そのホストを「UNREACHABLE」とマークし、実行時にアクティブなホストのリストから削除します。`meta: clear_host_errors` を使用してすべてのホストを再有効化することで、後続のタスクが再びホストに到達しようとすることができます。

en: Handlers and failure
ja: ハンドラーおよび失敗

en: Ansible runs :ref:`handlers <handlers>` at the end of each play. If a task notifies a handler but another task fails later in the play, by default the handler does *not* run on that host, which may leave the host in an unexpected state. For example, a task could update a configuration file and notify a handler to restart some service. If a task later in the same play fails, the configuration file might be changed but the service will not be restarted.
ja: Ansible は、各プレイの最後に :ref:`handlers <handlers>` を実行します。タスクがハンドラーに通知しても、プレイの後半で別のタスクが失敗すると、デフォルトではハンドラーはそのホスト上で **実行されず**、ホストが予期せぬ状態になる可能性があります。たとえば、タスクが設定ファイルを更新し、ハンドラーにサービスの再起動を通知したとします。同じプレイの後半でタスクが失敗した場合、設定ファイルは変更するかもしれませんが、サービスは再起動しません。

en: You can change this behavior with the ``--force-handlers`` command-line option, by including ``force_handlers: True`` in a play, or by adding ``force_handlers = True`` to ansible.cfg. When handlers are forced, Ansible will run all notified handlers on all hosts, even hosts with failed tasks. (Note that certain errors could still prevent the handler from running, such as a host becoming unreachable.)
ja: この動作は、``force_handlers: True`` をプレイに含めるか、``force_handlers = True`` を ansible.cfg に追加して、``--force-handlers`` コマンドラインオプションで変更できます。ハンドラーが強制的に実行すると、Ansible は通知されたすべてのハンドラーを、タスクが失敗したホストも含めてすべてのホストで実行します (ホストが到達不能になるなど、特定のエラーによってハンドラーの実行が妨げられる可能性があることに注意してください)。

en: Defining failure
ja: 障害の定義

en: Ansible lets you define what "failure" means in each task using the ``failed_when`` conditional. As with all conditionals in Ansible, lists of multiple ``failed_when`` conditions are joined with an implicit ``and``, meaning the task only fails when *all* conditions are met. If you want to trigger a failure when any of the conditions is met, you must define the conditions in a string with an explicit ``or`` operator.
ja: Ansible では、``failed_when`` 条件分岐を使用して、各タスクで「失敗」の意味を定義することができます。Ansible のすべての条件分岐と同様に、複数の ``failed_when`` 条件のリストは暗黙の ``and`` で結合されており、これは *すべての* 条件が満たされたときにのみタスクが失敗することを意味します。いずれかの条件が満たされたときに失敗をトリガーしたい場合は、明示的な ``or`` 演算子を使用して文字列で条件を定義する必要があります。

en: You may check for failure by searching for a word or phrase in the output of a command::
ja: コマンドの出力で単語またはフレーズを検索して、障害の有無を確認できます。

en: or based on the return code::
ja: または、戻りコードに基いて確認できます。

en: You can also combine multiple conditions for failure. This task will fail if both conditions are true::
ja: 複数の条件を組み合わせて失敗させることもできます。このタスクは、両方の条件が真であれば失敗します。

en: If you want the task to fail when only one condition is satisfied, change the ``failed_when`` definition to::
ja: 条件が満たされたときにのみタスクが失敗する場合は、``failed_when`` 定義を以下のように変更します。

en: If you have too many conditions to fit neatly into one line, you can split it into a multi-line yaml value with ``>``::
ja: 条件が多すぎて 1 行にうまく収まらない場合は、``>`` を使用して、これを複数行の yaml 値に分割できます。

en: Defining "changed"
ja: 「変更済み」の定義

en: Ansible lets you define when a particular task has "changed" a remote node using the ``changed_when`` conditional. This lets you determine, based on return codes or output, whether a change should be reported in Ansible statistics and whether a handler should be triggered or not. As with all conditionals in Ansible, lists of multiple ``changed_when`` conditions are joined with an implicit ``and``, meaning the task only reports a change when *all* conditions are met. If you want to report a change when any of the conditions is met, you must define the conditions in a string with an explicit ``or`` operator. For example::
ja: Ansible では、``changed_when`` 条件式を使用して、特定のタスクがリモートノードを「変更」したときを定義することができます。これにより、戻りコードや出力に基づいて、変更を Ansible の統計で報告するかどうか、ハンドラーをトリガーするかどうかを決定することができます。Ansible のすべての条件式と同様に、複数の``changed_when`` 条件のリストは暗黙の ``and`` で結合されており、タスクは *すべての* 条件が満たされたときにのみ変更を報告することを意味します。いずれかの条件が満たされたときに変更を報告したい場合は、明示的な ``or`` 演算子を使用して文字列で条件を定義する必要があります。以下に例を示します。

en: You can also combine multiple conditions to override "changed" result::
ja: 複数の条件を組み合わせて「変更」の結果を上書きすることもできます。

en: See :ref:`controlling_what_defines_failure` for more conditional syntax examples.
ja: その他の条件付き構文例については、「:ref:`controlling_what_defines_failure`」を参照してください。

en: Ensuring success for command and shell
ja: コマンドとシェルの成功の確認

en: The :ref:`command <command_module>` and :ref:`shell <shell_module>` modules care about return codes, so if you have a command whose successful exit code is not zero, you can do this::
ja: :ref:`command <command_module>` モジュールおよび :ref:`shell <shell_module>` モジュールは戻りコードを処理するため、正常な終了コードがゼロではないこまんどがある場合は、以下を行うことができます。

en: Aborting a play on all hosts
ja: すべてのホストでプレイを中止

en: Sometimes you want a failure on a single host, or failures on a certain percentage of hosts, to abort the entire play on all hosts. You can stop play execution after the first failure happens with ``any_errors_fatal``. For finer-grained control, you can use ``max_fail_percentage`` to abort the run after a given percentage of hosts has failed.
ja: 時には、1 つのホストでの失敗や、ある割合のホストでの失敗により、すべてのホストでのプレイ全体を中止させたいことがあります。``any_errors_fatal`` を使用すると、最初の失敗が発生した後にプレイの実行を停止することができます。より細かく制御するには、``max_fail_percentage`` を使用して、特定の割合のホストで失敗した後に実行を中止することができます。

en: Aborting on the first error: any_errors_fatal
ja: 最初のエラーで強制終了: any_errors_fatal

en: If you set ``any_errors_fatal`` and a task returns an error, Ansible finishes the fatal task on all hosts in the current batch, then stops executing the play on all hosts. Subsequent tasks and plays are not executed. You can recover from fatal errors by adding a :ref:`rescue section <block_error_handling>` to the block. You can set ``any_errors_fatal`` at the play or block level::
ja: ``any_errors_fatal`` を設定し、タスクがエラーを返した場合、Ansible は現在のバッチ内のすべてのホストで致命的なタスクを終了し、すべてのホストでプレイの実行を停止します。後続のタスクやプレイは実行されません。致命的なエラーから回復するには、ブロックに :ref:`rescue section <block_error_handling>` を追加します。``any_errors_fatal`` は、プレイまたはブロックレベルで設定できます。

en: You can use this feature when all tasks must be 100% successful to continue playbook execution. For example, if you run a service on machines in multiple data centers with load balancers to pass traffic from users to the service, you want all load balancers to be disabled before you stop the service for maintenance. To ensure that any failure in the task that disables the load balancers will stop all other tasks::
ja: この機能は、Playbook の実行を継続するために、すべてのタスクが 100％ 成功する必要がある場合に使用できます。たとえば、複数のデータセンターにあるマシンでサービスを実行し、ユーザーからのトラフィックをサービスに渡すためにロードバランサーを使用している場合は、メンテナンスのためにサービスを停止する前に、すべてのロードバランサーを無効にします。ロードバランサーを無効にするタスクに障害が発生しても、他のすべてのタスクを停止させるには、次のようにします。

en: In this example Ansible starts the software upgrade on the front ends only if all of the load balancers are successfully disabled.
ja: この例では、すべてのロードバランサーが正常に無効になっている場合にのみ、Ansible が、フロントエンドでソフトウェアのアップグレードを開始します。

en: Setting a maximum failure percentage
ja: 最大失敗率の設定

en: By default, Ansible continues to execute tasks as long as there are hosts that have not yet failed. In some situations, such as when executing a rolling update, you may want to abort the play when a certain threshold of failures has been reached. To achieve this, you can set a maximum failure percentage on a play::
ja: デフォルトでは、Ansible はまだ失敗していないホストがある限り、タスクを実行し続けます。ローリングアップデートを実行する場合など、ある一定の失敗率に達したときにプレイを中断したい場合があります。これを可能にするには、プレイの最大失敗率を設定することができます。

en: The ``max_fail_percentage`` setting applies to each batch when you use it with :ref:`serial <rolling_update_batch_size>`. In the example above, if more than 3 of the 10 servers in the first (or any) batch of servers failed, the rest of the play would be aborted.
ja: ``max_fail_percentage`` の設定は、:ref:`serial <rolling_update_batch_size>` と一緒に使用すると、各バッチに適用されます。上の例では、最初の (あるいは任意の) バッチに含まれる 10 台のサーバーのうち 3 台以上が故障した場合、残りのプレイは中止されます。

en: The percentage set must be exceeded, not equaled. For example, if serial were set to 4 and you wanted the task to abort the play when 2 of the systems failed, set the max_fail_percentage at 49 rather than 50.
ja: 設定されたパーセンテージは、同等ではなく、超えなければなりません。たとえば、serialが 4 に設定されていて、2 つのシステムが故障したときにプレイを中止するタスクにしたい場合は、max_fail_percentage を 50 ではなく 49 に設定します。

en: Controlling errors in blocks
ja: ブロックのエラーを制御

en: You can also use blocks to define responses to task errors. This approach is similar to exception handling in many programming languages. See :ref:`block_error_handling` for details and examples.
ja: ブロックを使用してタスクエラーへの応答を定義することもできます。この方法は、多くのプログラミング言語での例外処理に似ています。詳細と例は、「:ref:`block_error_handling`」を参照してください。

en: Conditional statements in playbooks
ja: Playbook の条件付きステートメント

en: Using filters to manipulate data
ja: フィルターを使用したデータの操作

en: Filters let you transform JSON data into YAML data, split a URL to extract the hostname, get the SHA1 hash of a string, add or multiply integers, and much more. You can use the Ansible-specific filters documented here to manipulate your data, or use any of the standard filters shipped with Jinja2 - see the list of :ref:`built-in filters <jinja2:builtin-filters>` in the official Jinja2 template documentation. You can also use :ref:`Python methods <jinja2:python-methods>` to transform data. You can :ref:`create custom Ansible filters as plugins <developing_filter_plugins>`, though we generally welcome new filters into the ansible-core repo so everyone can use them.
ja: フィルターを使用すると、JSON データを YAML データに変換したり、URL を分割してホスト名を抽出したり、文字列の SHA1 ハッシュを取得したり、整数を加算または乗算したりなど、さまざまなことができます。ここで紹介している Ansible 固有のフィルターを使用してデータを操作することもできますし、Jinja2 に同梱されている標準的なフィルターを使用することもできます。Jinja2 の公式テンプレートドキュメントの :ref:`組み込みフィルター <jinja2:builtin-filters>` のリストを参照してださい。また、:ref:`Python メソッド <jinja2:python-methods>` を使用してデータを変換することもできます。:ref:`カスタム Ansible フィルターをプラグインとして作成 <developing_filter_plugins>` することもできますが、通常は、誰もが使用できるように新しいフィルターを ansible-core リポジトリーに追加することが歓迎されています。

en: Because templating happens on the Ansible controller, **not** on the target host, filters execute on the controller and transform data locally.
ja: テンプレート化はターゲットホスト上 **ではなく**、Ansible コントローラー上で行われるため、フィルターはコントローラ上で実行し、データはローカルに変換されます。

en: Handling undefined variables
ja: 未定義変数の処理

en: Filters can help you manage missing or undefined variables by providing defaults or making some variables optional. If you configure Ansible to ignore most undefined variables, you can mark some variables as requiring values with the ``mandatory`` filter.
ja: フィルターは、デフォルトを指定したり、一部の変数を任意にしたりすることで、欠落している変数や未定義の変数を管理するのに役立ちます。ほとんどの未定義の変数を無視するように Ansibl eを設定した場合は、``mandatory`` フィルターを使用して、いくつかの変数を必要な値としてマークすることができます。

en: Providing default values
ja: デフォルト値の指定

en: You can provide default values for variables directly in your templates using the Jinja2 'default' filter. This is often a better approach than failing if a variable is not defined::
ja: Jinja2 の「default」フィルターを使用すれば、テンプレートの中で直接、変数のデフォルト値を指定することができます。変数が定義されていない場合に失敗するよりも優れたアプローチであることがよくあります。

en: In the above example, if the variable 'some_variable' is not defined, Ansible uses the default value 5, rather than raising an "undefined variable" error and failing. If you are working within a role, you can also add a ``defaults/main.yml`` to define the default values for variables in your role.
ja: 上記の例では、変数「some_variable」が定義されていない場合、Ansible は「undefined variable」エラーを発生させて失敗するのではなく、デフォルト値 5 を使用します。ロール内で作業している場合は、``defaults/main.yml`` を追加して、ロール内の変数のデフォルト値を定義することもできます。

en: Beginning in version 2.8, attempting to access an attribute of an Undefined value in Jinja will return another Undefined value, rather than throwing an error immediately. This means that you can now simply use a default with a value in a nested data structure (in other words, :code:`{{ foo.bar.baz | default('DEFAULT') }}`) when you do not know if the intermediate values are defined.
ja: バージョン 2.8 から、Jinja で Undefined の値の属性にアクセスしようとすると、すぐにエラーが発生するのではなく、別の Undefined の値が返されます。これにより、中間値が定義されているかどうかわからない場合に、ネストされたデータ構造の中の値でデフォルトを簡単に使用することができるようになりました (つまり :code:`{{ foo.bar.baz | default('DEFAULT') }}`)。

en: If you want to use the default value when variables evaluate to false or an empty string you have to set the second parameter to ``true``::
ja: 変数が false または空の文字列に評価されるときにデフォルト値を使用する場合は、2 番目のパラメーターを ``true`` に設定する必要があります。

en: Making variables optional
ja: 変数の任意設定

en: By default Ansible requires values for all variables in a templated expression. However, you can make specific variables optional. For example, you might want to use a system default for some items and control the value for others. To make a variable optional, set the default value to the special variable ``omit``::
ja: デフォルトでは、Ansible はテンプレート式のすべての変数に値を要求します。しかし、特定の変数を任意にすることができます。たとえば、一部の項目ではシステムのデフォルト値を使用し、他の項目では値を制御することができます。変数を任意にするには、特殊変数 ``omit`` にデフォルト値を設定します。

en: In this example, the default mode for the files ``/tmp/foo`` and ``/tmp/bar`` is determined by the umask of the system. Ansible does not send a value for ``mode``. Only the third file, ``/tmp/baz``, receives the `mode=0444` option.
ja: この例では、``/tmp/foo`` ファイルおよび ``/tmp/bar`` ファイルのデフォルトモードはシステムの umask により決定されます。Ansible は ``mode`` の値を送信しません。3 番目のファイルである ``/tmp/baz`` だけが `mode=0444` オプションを受け取ります。

en: If you are "chaining" additional filters after the ``default(omit)`` filter, you should instead do something like this: ``"{{ foo | default(None) | some_filter or omit }}"``. In this example, the default ``None`` (Python null) value will cause the later filters to fail, which will trigger the ``or omit`` portion of the logic. Using ``omit`` in this manner is very specific to the later filters you are chaining though, so be prepared for some trial and error if you do this.
ja: ``default(omit)`` フィルターの後に追加のフィルターを「連鎖」させる場合は、代わりに ``"{{ foo | default(None) | some_filter or omit }}"`` のようにしてください。この例では、デフォルトの ``None`` (Python null) の値により、後続のフィルターが失敗し、ロジックの ``or omit`` 部分が誘発されます。``omit`` をこのように使用することは、連鎖させる後続のフィルターに非常に依存するため、試行錯誤が必要になります。

en: Defining mandatory values
ja: 必須値の定義

en: If you configure Ansible to ignore undefined variables, you may want to define some values as mandatory. By default, Ansible fails if a variable in your playbook or command is undefined. You can configure Ansible to allow undefined variables by setting :ref:`DEFAULT_UNDEFINED_VAR_BEHAVIOR` to ``false``. In that case, you may want to require some variables to be defined. You can do this with::
ja: 未定義の変数を無視するように Ansible を設定する場合は、一部の値を必須として定義したい場合があります。デフォルトでは、Playbook またはコマンドの変数が未定義の場合、Ansible は失敗します。:ref:`DEFAULT_UNDEFINED_VAR_BEHAVIOR` を ``false`` に設定することで、未定義の変数を許可するように Ansible を設定することができます。その場合は、一部の変数の定義を必須にしたい場合があります。これには次の方法があります。

en: The variable value will be used as is, but the template evaluation will raise an error if it is undefined.
ja: 変数の値はそのまま使用されますが、定義されていない場合は、テンプレートの評価でエラーが発生します。

en: Defining different values for true/false/null (ternary)
ja: true/false/null (三項) に異なる値を定義する

en: You can create a test, then define one value to use when the test returns true and another when the test returns false (new in version 1.9)::
ja: テストを作成し、そのテストが true を返したときに使用する値と、false を返したときに使用する値を定義することができます (バージョン 1.9 の新機能)。

en: In addition, you can define a one value to use on true, one value on false and a third value on null (new in version 2.8)::
ja: さらに、true に使用する値を 1 つ定義し、false で 1 つの値、null で 3 番目の値を定義できます (バージョン 2.8 の新機能)。

en: Managing data types
ja: データ型の管理

en: You might need to know, change, or set the data type on a variable. For example, a registered variable might contain a dictionary when your next task needs a list, or a user :ref:`prompt <playbooks_prompts>` might return a string when your playbook needs a boolean value. Use the ``type_debug``, ``dict2items``, and ``items2dict`` filters to manage data types. You can also use the data type itself to cast a value as a specific data type.
ja: 変数のデータ型の確認、変更、または設定を行う必要がある場合があります。たとえば、次のタスクでリストが必要なときに、登録済みの変数にディクショナリーが含まれていたり、Playbook でブール値が必要なときに、ユーザーの :ref:`prompt <playbooks_prompts>` が文字列を返したりすることがあります。データタイプの管理には、``type_debug``、``dict2items``、および ``items2dict`` の各フィルターを使用します。また、データ型自体を使用して、値を特定のデータ型としてキャストすることもできます。

en: Discovering the data type
ja: データ型の検出

en: If you are unsure of the underlying Python type of a variable, you can use the ``type_debug`` filter to display it. This is useful in debugging when you need a particular type of variable::
ja: 変数の基礎となる Python の型がわからない場合は、``type_debug`` フィルターを使用して表示することができます。これはデバッグ時に特定の型の変数が必要になったときに便利です。

en: Transforming dictionaries into lists
ja: ディクショナリーのリストへの変換

en: Use the ``dict2items`` filter to transform a dictionary into a list of items suitable for :ref:`looping <playbooks_loops>`::
ja: ``dict2items`` フィルターを使用して、ディクショナリーを :ref:`looping <playbooks_loops>` に適した項目のリストに変換します。

en: Dictionary data (before applying the ``dict2items`` filter)::
ja: ディクショナリーデータ (``dict2items`` フィルターを適用する前)::

en: List data (after applying the ``dict2items`` filter)::
ja: データを一覧表示 (``dict2items`` フィルターを適用した後)::

en: The ``dict2items`` filter is the reverse of the ``items2dict`` filter.
ja: ``dict2items`` フィルターは、``items2dict`` フィルターの逆の効果があります。

en: If you want to configure the names of the keys, the ``dict2items`` filter accepts 2 keyword arguments. Pass the ``key_name`` and ``value_name`` arguments to configure the names of the keys in the list output::
ja: キー名を設定する場合は、``dict2items`` フィルターは 2 つのキーワード引数を受け入れます。``key_name`` 引数および ``value_name`` 引数を渡すと、リスト出力のキーの名前を設定します。

en: Transforming lists into dictionaries
ja: リストのディクショナリーへの変換

en: Use the ``items2dict`` filter to transform a list into a dictionary, mapping the content into ``key: value`` pairs::
ja: ``items2dict`` フィルターを使用してリストをディクショナリーに変換し、コンテンツを ``key: value`` のペアにマッピングします。

en: List data (before applying the ``items2dict`` filter)::
ja: データを一覧表示 (``items2dict`` フィルターを適用する前)::

en: Dictionary data (after applying the ``items2dict`` filter)::
ja: ディクショナリーデータ (``items2dict`` フィルターを適用した後)::

en: The ``items2dict`` filter is the reverse of the ``dict2items`` filter.
ja: ``items2dict`` フィルターは、``dict2items`` フィルターの逆の効果があります。

en: Not all lists use ``key`` to designate keys and ``value`` to designate values. For example::
ja: すべてのリストで、キーの指定に ``key`` を使用し、値の指定に ``value`` を使用しているわけではありません。以下に例を示します。

en: In this example, you must pass the ``key_name`` and ``value_name`` arguments to configure the transformation. For example::
ja: この例では、``key_name`` 引数と ``value_name`` 引数を渡すと、変換を設定する必要があります。以下に例を示します。

en: If you do not pass these arguments, or do not pass the correct values for your list, you will see ``KeyError: key`` or ``KeyError: my_typo``.
ja: これらの引数、またはリストに適した値を渡さない場合は、``KeyError: key`` または ``KeyError: my_typo`` が表示されます。

en: Forcing the data type
ja: データ型を強制

en: You can cast values as certain types. For example, if you expect the input "True" from a :ref:`vars_prompt <playbooks_prompts>` and you want Ansible to recognize it as a boolean value instead of a string::
ja: 値を特定の型にキャストすることができます。たとえば、:ref:`vars_prompt <playbooks_prompts>` から「True」という入力を期待していて、Ansible にそれを文字列ではなくブール値として認識させたい場合は、次のようになります。

en: If you want to perform a mathematical comparison on a fact and you want Ansible to recognize it as an integer instead of a string::
ja: ファクトに対して数学的な比較を実行し、Ansible が文字列ではなく整数として認識する場合は、以下を行います。

en: Formatting data: YAML and JSON
ja: データのフォーマット: YAML および JSON

en: You can switch a data structure in a template from or to JSON or YAML format, with options for formatting, indenting, and loading data. The basic filters are occasionally useful for debugging::
ja: テンプレート内のデータ構造を JSON 形式と YAML 形式との間で切り替えることができ、フォーマット化やインデント付け、データの読み込みなどのオプションも用意されています。基本的なフィルターは、時折、デバッグに役立ちます。

en: For human readable output, you can use::
ja: 人が判読できる出力にするには、以下を使用できます。

en: You can change the indentation of either format::
ja: いずれかの形式のインデントを変更できます。

en: The ``to_yaml`` and ``to_nice_yaml`` filters use the `PyYAML library`_ which has a default 80 symbol string length limit. That causes unexpected line break after 80th symbol (if there is a space after 80th symbol) To avoid such behavior and generate long lines, use the ``width`` option. You must use a hardcoded number to define the width, instead of a construction like ``float("inf")``, because the filter does not support proxying Python functions. For example::
ja: ``to_yaml`` フィルターおよび ``to_nice_yaml`` フィルターは、デフォルトで 80 記号の文字列長制限を持つ `PyYAML library`_ を使用しています。このため、80 番目の記号の後に予期せぬ改行が発生します (80 番目のシンボルの後に空白がある場合)。このような動作を回避し、長い行を生成するには、``width`` オプションを使用します。フィルターは Python 関数のプロキシーをサポートしていないため、``float("inf")`` のような構文ではなく、ハードコードされた数値を使用して幅を定義する必要があります。以下に例を示します。

en: The filter does support passing through other YAML parameters. For a full list, see the `PyYAML documentation`_.
ja: フィルターは他の YAML パラメーターのパススルーをサポートします。完全な一覧は、「`PyYAML documentation`_」を参照してください。

en: If you are reading in some already formatted data::
ja: すでにフォーマットされている一部のデータで読み取る場合::

en: for example::
ja: たとえば、以下のようになります。

en: Filter `to_json` and Unicode support
ja: `to_json` と Unicode サポートをフィルタリング

en: By default `to_json` and `to_nice_json` will convert data received to ASCII, so::
ja: デフォルトでは、`to_json` および `to_nice_json` は、受診したデータを ASCII に変換するため、次のようになります。

en: will return::
ja: 以下が返ってきます。

en: To keep Unicode characters, pass the parameter `ensure_ascii=False` to the filter::
ja: Unicode 文字を保持するには、パラメーター `ensure_ascii=False` をフィルターに渡します。

en: To parse multi-document YAML strings, the ``from_yaml_all`` filter is provided. The ``from_yaml_all`` filter will return a generator of parsed YAML documents.
ja: 複数ドキュメントの YAML 文字列を解析するために、``from_yaml_all`` フィルターが提供されます。``from_yaml_all`` フィルターは解析された YAML ドキュメントのジェネレーターを返します。

en: Combining and selecting data
ja: データの統合および選択

en: You can combine data from multiple sources and types, and select values from large data structures, giving you precise control over complex data.
ja: 複数のソースやタイプのデータを組み合わせたり、大規模なデータ構造から値を選択したりすることで、複雑なデータを正確に制御することができます。

en: Combining items from multiple lists: zip and zip_longest
ja: 複数のリストからの項目の組み合わせ: zip および zip_longest

en: To get a list combining the elements of other lists use ``zip``::
ja: 他のリストの要素を組み合わせたリストを取得するには、``zip`` を使用します。

en: To always exhaust all lists use ``zip_longest``::
ja: すべての一覧を常に使い切るには、``zip_longest`` を使用します。

en: Similarly to the output of the ``items2dict`` filter mentioned above, these filters can be used to construct a ``dict``::
ja: 上記の ``items2dict`` フィルターの出力と同様に、これらのフィルターを使用して ``dict`` を作成できます。

en: List data (before applying the ``zip`` filter)::
ja: リストデータ (``zip`` フィルターを適用する前)::

en: Dictionary data (after applying the ``zip`` filter)::
ja: ディクショナリーデータ (``zip`` フィルターを適用した後)::

en: Combining objects and subelements
ja: オブジェクトとサブ要素の統合

en: The ``subelements`` filter produces a product of an object and the subelement values of that object, similar to the ``subelements`` lookup. This lets you specify individual subelements to use in a template. For example, this expression::
ja: ``subelements`` フィルターは、``subelements`` ルックアップと同様に、オブジェクトとそのオブジェクトのサブエレメントの値の積を生成します。これにより、テンプレートで使用する個々のサブエレメントを指定することができます。たとえば、以下のような式になります。

en: Data before applying the ``subelements`` filter::
ja: ``subelements`` フィルターの適用前のデータ::

en: Data after applying the ``subelements`` filter::
ja: ``subelements`` フィルターの適用後のデータ::

en: You can use the transformed data with ``loop`` to iterate over the same subelement for multiple objects::
ja: 変換したデータを ``loop`` とともに使用して、複数のオブジェクトに対して同じサブ要素を繰り返すことができます。

en: Combining hashes/dictionaries
ja: ハッシュ/ディクショナリーの統合

en: The ``combine`` filter allows hashes to be merged. For example, the following would override keys in one hash::
ja: ``combine`` フィルターはハッシュをマージできます。たとえば、以下は 1 つのハッシュ内のキーをオーバーライドします。

en: The resulting hash would be::
ja: 生成されるハッシュは、以下のようになります。

en: The filter can also take multiple arguments to merge::
ja: フィルターは複数の引数を使用してマージすることもできます。

en: In this case, keys in ``d`` would override those in ``c``, which would override those in ``b``, and so on.
ja: この場合、``d`` のキーは ``c`` のキーを上書きし、``b`` のキーも同様に上書きされます。

en: The filter also accepts two optional parameters: ``recursive`` and ``list_merge``.
ja: フィルターは、``recursive`` および ``list_merge`` の 2 つの任意のパラメーターも使用できます。

en: recursive
ja: 再帰

en: Is a boolean, default to ``False``. Should the ``combine`` recursively merge nested hashes. Note: It does **not** depend on the value of the ``hash_behaviour`` setting in ``ansible.cfg``.
ja: ブール値で、デフォルトは ``False`` です。``combine`` が入れ子になったハッシュを再帰的にマージするかどうかを指定します。注: ``ansible.cfg`` の ``hash_behaviour`` 設定の値には **依存しません** 。

en: Is a string, its possible values are ``replace`` (default), ``keep``, ``append``, ``prepend``, ``append_rp`` or ``prepend_rp``. It modifies the behaviour of ``combine`` when the hashes to merge contain arrays/lists.
ja: 使用できる値は ``replace`` (デフォルト)、``keep``、``append``、``prepend``、``append_rp``、または ``prepend_rp`` です。ハッシュに配列/リストをマージする際に ``combine`` の動作を変更します。

en: If ``recursive=False`` (the default), nested hash aren't merged::
ja: ``recursive=False`` (デフォルト) の場合は、ネストされたハッシュがマージされません。

en: This would result in::
ja: これにより、以下のようになります。

en: If ``recursive=True``, recurse into nested hash and merge their keys::
ja: ``recursive=True`` の場合は、ネストされたハッシュを再帰的に使用して、鍵をマージします。

en: If ``list_merge='replace'`` (the default), arrays from the right hash will "replace" the ones in the left hash::
ja: ``list_merge='replace'`` (デフォルト) の場合、右ハッシュの配列は左ハッシュの配列を「置き換え」ます。

en: If ``list_merge='keep'``, arrays from the left hash will be kept::
ja: ``list_merge='keep'`` の場合は、左のハッシュからの配列が保持されます。

en: If ``list_merge='append'``, arrays from the right hash will be appended to the ones in the left hash::
ja: ``list_merge='append'`` の場合は、右のハッシュからの配列が左のハッシュ内の配列に追加されます。

en: If ``list_merge='prepend'``, arrays from the right hash will be prepended to the ones in the left hash::
ja: ``list_merge='prepend'`` の場合は、右のハッシュからの配列が左のハッシュ内の配列の前に追加されます。

en: If ``list_merge='append_rp'``, arrays from the right hash will be appended to the ones in the left hash. Elements of arrays in the left hash that are also in the corresponding array of the right hash will be removed ("rp" stands for "remove present"). Duplicate elements that aren't in both hashes are kept::
ja: ``list_merge='append_rp'`` の場合は、右ハッシュの配列が、左ハッシュの配列に追加されます。左ハッシュの配列のうち、右ハッシュの対応する配列にもある要素は削除されます (「rp」は「remove present」の略)。両方のハッシュに存在しない重複した要素は保持されます。

en: If ``list_merge='prepend_rp'``, the behavior is similar to the one for ``append_rp``, but elements of arrays in the right hash are prepended::
ja: ``list_merge='prepend_rp'`` の場合、動作は ``append_rp`` のものと似ていますが、右のハッシュ内の配列の要素の前に追加されます。

en: ``recursive`` and ``list_merge`` can be used together::
ja: ``recursive`` および ``list_merge`` は一緒に使用できます。

en: Selecting values from arrays or hashtables
ja: 配列またはハッシュテーブルからの値の選択

en: The `extract` filter is used to map from a list of indices to a list of values from a container (hash or array)::
ja: `extract` フィルターは、インデックスのリストから、コンテナー (ハッシュまたは配列) の値のリストへのマッピングに使用されます。

en: The results of the above expressions would be::
ja: 上記の式の結果は、以下のようになります。

en: The filter can take another argument::
ja: フィルターは別の引数を取ることができます。

en: This takes the list of hosts in group 'x', looks them up in `hostvars`, and then looks up the `ec2_ip_address` of the result. The final result is a list of IP addresses for the hosts in group 'x'.
ja: これにより、グループ「x」のホスト一覧が `hostvars` で検索され、結果の `ec2_ip_address` を探します。最終結果は、グループ「x」のホストの IP アドレス一覧になります。

en: The third argument to the filter can also be a list, for a recursive lookup inside the container::
ja: フィルターの第 3 引数にはリストを指定することもでき、コンテナー内の再帰的な検索が可能です。

en: This would return a list containing the value of `b['a']['x']['y']`.
ja: これにより、`b['a']['x']['y']` の値が含まれるリストが返されます。

en: Combining lists
ja: リストの統合

en: This set of filters returns a list of combined lists.
ja: このフィルターセットは、組み合わせたリストを返します。

en: permutations
ja: 置換

en: To get permutations of a list::
ja: リストの置換を取得するには、以下を実行します。

en: combinations
ja: 組み合わせ

en: Combinations always require a set size::
ja: 組み合わせには常にセットサイズが必要です。

en: Also see the :ref:`zip_filter`
ja: また、「:ref:`zip_filter`」を参照してください。

en: products
ja: 製品

en: The product filter returns the `cartesian product <https://docs.python.org/3/library/itertools.html#itertools.product>`_ of the input iterables. This is roughly equivalent to nested for-loops in a generator expression.
ja: 製品フィルターは、入力されたイテラブルの `cartesian product <https://docs.python.org/3/library/itertools.html#itertools.product>`_ を返します。これはジェネレータ式の入れ子になった for-loop とほぼ同じです。

en: Selecting JSON data: JSON queries
ja: JSON データの選択: JSON クエリー

en: To select a single element or a data subset from a complex data structure in JSON format (for example, Ansible facts), use the ``json_query`` filter.  The ``json_query`` filter lets you query a complex JSON structure and iterate over it using a loop structure.
ja: JSON 形式の複雑なデータ構造 (Ansible ファクトなど) から単一の要素やデータサブセットを選択するには、``json_query`` フィルターを使用します。``json_query`` フィルターを使用すると、複雑な JSON 構造を照会し、ループ構造を使用して反復処理することができます。

en: This filter has migrated to the `community.general <https://galaxy.ansible.com/community/general>`_ collection. Follow the installation instructions to install that collection.
ja: `community.general <https://galaxy.ansible.com/community/general>`_ フィルターはコレクションに移行しました。インストール手順に従ってそのコレクションをインストールします。

en: You must manually install the **jmespath** dependency on the Ansible controller before using this filter. This filter is built upon **jmespath**, and you can use the same syntax. For examples, see `jmespath examples <http://jmespath.org/examples.html>`_.
ja: このフィルターを使用する前に、Ansible コントローラーに **jmespath** 依存関係を手動でインストールする必要があります。このフィルターは **jmespath** をベースに作られており、同じ構文を使用することができます。例については、`jmespath の例 <http://jmespath.org/examples.html>`_ を参照してください。

en: Consider this data structure::
ja: このデータ構造を考えてみましょう。

en: To extract all clusters from this structure, you can use the following query::
ja: この構造からすべてのクラスターを抽出するには、以下のクエリーを使用できます。

en: To extract all server names::
ja: すべてのサーバー名を抽出するには、以下を実行します。

en: To extract ports from cluster1::
ja: cluster1 からポートを抽出するには、以下を実行します。

en: You can use a variable to make the query more readable.
ja: 変数を使用すると、クエリーの読み取りがより容易になります。

en: To print out the ports from cluster1 in a comma separated string::
ja: cluster1 のポートをコンマ区切りの文字列で表示するには、以下を行います。

en: In the example above, quoting literals using backticks avoids escaping quotes and maintains readability.
ja: 上の例では、リテラルを backtick で引用することで、引用符のエスケープを避け、読みやすさを維持しています。

en: You can use YAML `single quote escaping <https://yaml.org/spec/current.html#id2534365>`_::
ja: YAML の `一重引用符のエスケープ <https://yaml.org/spec/current.html#id2534365>`_ を使用できます。

en: Escaping single quotes within single quotes in YAML is done by doubling the single quote.
ja: YAML の一重引用符内で一重引用符をエスケープする場合は、一重引用符を二重にします。

en: To get a hash map with all ports and names of a cluster::
ja: クラスターのすべてのポートおよび名前を持つハッシュマップを取得するには、以下を行います。

en: To extract ports from all clusters with name starting with 'server1'::
ja: 「server1」で始まる名前の全クラスターからポートを抽出するには、以下を行います。

en: To extract ports from all clusters with name containing 'server1'::
ja: 「server1」を含む名前の全クラスターからポートを抽出するには、以下を行います。

en: while using ``starts_with`` and ``contains``, you have to use `` to_json | from_json `` filter for correct parsing of data structure.
ja: ``starts_with`` および ``contains`` を使用する場合は、データ構造を正しく解析するために `` to_json | from_json `` フィルターを使用する必要があります。

en: Randomizing data
ja: データのランダム化

en: When you need a randomly generated value, use one of these filters.
ja: ランダムに生成された値が必要な場合は、これらのフィルターのいずれかを使用します。

en: Random MAC addresses
ja: ランダムな MAC アドレス

en: This filter can be used to generate a random MAC address from a string prefix.
ja: このフィルターは、文字列プレフィックスからランダムな MAC アドレスを生成するために使用できます。

en: To get a random MAC address from a string prefix starting with '52:54:00'::
ja: 文字列プレフィックス「52:54:00」で始まるランダムな MAC アドレスを取得するには、次のコマンドを実行します。

en: Note that if anything is wrong with the prefix string, the filter will issue an error.
ja: プレフィックスの文字列で不具合が生じた場合は、フィルターによりエラーが生じることに注意してください。

en: As of Ansible version 2.9, you can also initialize the random number generator from a seed to create random-but-idempotent MAC addresses::
ja: Ansible バージョン 2.9 以降では、シードから乱数ジェネレーターを初期化し、ランダムで冪等な MAC アドレスを作成することもできます。

en: Random items or numbers
ja: ランダムな項目または数字

en: The ``random`` filter in Ansible is an extension of the default Jinja2 random filter, and can be used to return a random item from a sequence of items or to generate a random number based on a range.
ja: Ansible の``random`` フィルターは、デフォルトの Jinja2 ランダムフィルターを拡張したもので、一連のアイテムからランダムな項目を返したり、範囲に基づいてランダムな数値を生成したりするのに使用できます。

en: To get a random item from a list::
ja: リストからランダムなアイテムを取得するには、以下を実行します。

en: To get a random number between 0 (inclusive) and a specified integer (exclusive)::
ja: 0 (含む) から指定した整数 (除く) の間の乱数を取得するには、次のようにします。

en: To get a random number from 0 to 100 but in steps of 10::
ja: 0 から 100 までの 10 のステップで乱数を取得するには、以下を行います。

en: To get a random number from 1 to 100 but in steps of 10::
ja: 1 から 100 までの 10 のステップで乱数を取得するには、以下を行います。

en: You can initialize the random number generator from a seed to create random-but-idempotent numbers::
ja: シードから乱数ジェネレーターを初期化し、ランダムで冪等な数字を作成できます。

en: If you use the ``seed`` parameter, you will get a different result with Python 3 and Python 2. This may break procedures such as password generation when you upgrade the version of Python used on your Ansible controller.
ja: ``seed`` パラメーターを使用した場合は、Python 3 と Python 2 で異なる結果が得られます。これにより、Ansible コントローラーで使用している Python のバージョンをアップグレードした場合は、パスワード生成などの手順が破綻する可能性があります。

en: Shuffling a list
ja: リストのシャッフル

en: The ``shuffle`` filter randomizes an existing list, giving a different order every invocation.
ja: ``shuffle`` フィルターは、既存のリストをランダム化し、呼び出しごとに異なる順序を提供します。

en: To get a random list from an existing  list::
ja: 既存のリストからランダムなリストを取得するには、以下を実行します。

en: You can initialize the shuffle generator from a seed to generate a random-but-idempotent order::
ja: シャッフルジェネレーターをシードから初期化して、ランダムで冪等な順序を生成することができます。

en: The shuffle filter returns a list whenever possible. If you use it with a non 'listable' item, the filter does nothing.
ja: シャッフルフィルターは可能な場合常にリストを返します。「リスト可能」ではない項目で使用すると、フィルターは何も行いません。

en: Managing list variables
ja: リスト変数の管理

en: You can search for the minimum or maximum value in a list, or flatten a multi-level list.
ja: リストの最小値や最大値を検索したり、複数レベルのリストをフラットにすることができます。

en: To get the minimum value from list of numbers::
ja: 数値リストから最小値を取得するには、以下を実行します。

en: To get the minimum value in a list of objects::
ja: オブジェクトのリストで最小値を取得するには、以下を実行します。

en: To get the maximum value from a list of numbers::
ja: 数値リストから最大値を取得するには、以下を実行します。

en: To get the maximum value in a list of objects::
ja: オブジェクトのリストで最大値を取得するには、以下を実行します。

en: Flatten a list (same thing the `flatten` lookup does)::
ja: リストをフラット化します (`flatten` ルックアップと同等)。

en: Flatten only the first level of a list (akin to the `items` lookup)::
ja: リストの最初のレベルのみをフラット化します (`items` ルックアップと同等)。

en: Preserve nulls in a list, by default flatten removes them. ::
ja: リストに null を保持します。デフォルトでは、フラット化はこれらを削除します。

en: Selecting from sets or lists (set theory)
ja: セットまたはリストの中から選択 (理論の設定)

en: You can select or combine items from sets or lists.
ja: セットまたはリストから項目を選択または組み合わせることができます。

en: To get a unique set from a list::
ja: リストから一意のセットを取得するには、以下を指定します。

en: To get a union of two lists::
ja: 2 つのリストを組み合わせて取得するには、以下を指定します。

en: To get the intersection of 2 lists (unique list of all items in both)::
ja: 2 つのリスト (両方の全項目の一意のリスト) で構成されるものを取得するには、以下を指定します。

en: To get the difference of 2 lists (items in 1 that don't exist in 2)::
ja: 2 つのリストの相違点を取得するには (2 に存在しない 1 の項目)、以下を指定します。

en: To get the symmetric difference of 2 lists (items exclusive to each list)::
ja: 2 つのリストの対称的な違いを取得する (各リストへの除外) には、以下を指定します。

en: Calculating numbers (math)
ja: 数字の計算 (数学)

en: You can calculate logs, powers, and roots of numbers with Ansible filters. Jinja2 provides other mathematical functions like abs() and round().
ja: Ansible のフィルターを使用して、対数、累乗、おより根を計算することができます。また、Jinja2 には abs() や round() などの数学関数も用意されています。

en: Get the logarithm (default is e)::
ja: 対数を取得します (デフォルトは e)。

en: Get the base 10 logarithm::
ja: ベース 10 の対数を取得します。

en: Give me the power of 2! (or 5)::
ja: 2 の累乗 (または 5)::

en: Square root, or the 5th::
ja: 平方根または 5 番目::

en: Managing network interactions
ja: ネットワーク対話の管理

en: These filters help you with common network tasks.
ja: これらのフィルターは、一般的なネットワークタスクの使用に役立ちます。

en: These filters have migrated to the `ansible.netcommon <https://galaxy.ansible.com/ansible/netcommon>`_ collection. Follow the installation instructions to install that collection.
ja: これらのフィルターは `ansible.netcommon <https://galaxy.ansible.com/ansible/netcommon>`_ コレクションに移行しました。インストール手順に従ってそのコレクションをインストールします。

en: IP address filters
ja: IP アドレスフィルター

en: To test if a string is a valid IP address::
ja: 文字列が有効な IP アドレスかどうかをテストするには、以下を実行します。

en: You can also require a specific IP protocol version::
ja: さらに、特定の IP プロトコルバージョンが必要です。

en: IP address filter can also be used to extract specific information from an IP address. For example, to get the IP address itself from a CIDR, you can use::
ja: IP アドレスフィルターを使用して、IP アドレスから特定の情報を抽出することもできます。たとえば、CIDR から IP アドレス自体を取得するには、以下を使用します。

en: More information about ``ipaddr`` filter and complete usage guide can be found in :ref:`playbooks_filters_ipaddr`.
ja: ``ipaddr`` フィルターの詳細と完全な使用ガイドは、「:ref:`playbooks_filters_ipaddr`」にあります。

en: Network CLI filters
ja: ネットワーク CLI フィルター

en: To convert the output of a network device CLI command into structured JSON output, use the ``parse_cli`` filter::
ja: ネットワーク機器の CLI コマンドの出力を構造化された JSON 出力に変換するには、``parse_cli`` フィルターを使用します。

en: The ``parse_cli`` filter will load the spec file and pass the command output through it, returning JSON output. The YAML spec file defines how to parse the CLI output.
ja: ``parse_cli`` フィルターは、spec ファイルを読み込み、コマンド出力を通して JSON 出力を返します。YAML の spec ファイルは、CLI 出力をどのように解析するかを定義します。

en: The spec file should be valid formatted YAML.  It defines how to parse the CLI output and return JSON data.  Below is an example of a valid spec file that will parse the output from the ``show vlan`` command.
ja: spec ファイルは有効な形式の YAML でなければなりません。CLI の出力をどのように解析し、JSON データを返すかを定義します。以下は、``show vlan`` コマンドからの出力を解析する有効な spec ファイルの例です。

en: The spec file above will return a JSON data structure that is a list of hashes with the parsed VLAN information.
ja: 上記の spec ファイルは、解析された VLAN 情報を持つハッシュのリストである JSON データ構造を返します。

en: The same command could be parsed into a hash by using the key and values directives.  Here is an example of how to parse the output into a hash value using the same ``show vlan`` command.
ja: 同じコマンドでも、鍵と値のディレクティブを使用することで、ハッシュに解析することができます。以下は、同じ ``show vlan`` コマンドを使用して出力をハッシュ値に解析する例です。

en: Another common use case for parsing CLI commands is to break a large command into blocks that can be parsed.  This can be done using the ``start_block`` and ``end_block`` directives to break the command into blocks that can be parsed.
ja: CLI コマンドを解析するもう一つの一般的なユースケースは、大きなコマンドを解析可能なブロックに分割することです。これは、``start_block`` ディレクティブと ``end_block`` ディレクティブを使用して、コマンドを解析可能なブロックに分割することで行います。

en: The example above will parse the output of ``show interface`` into a list of hashes.
ja: 上の例では、``show interface`` の出力を解析して、ハッシュのリストを作成します。

en: The network filters also support parsing the output of a CLI command using the TextFSM library.  To parse the CLI output with TextFSM use the following filter::
ja: ネットワークフィルターは、TextFSM ライブラリーを使用して CLI コマンドの出力の解析もサポートします。TextFSM で CLI 出力を解析するには、以下のフィルターを使用します。

en: Use of the TextFSM filter requires the TextFSM library to be installed.
ja: TextFSM フィルターを使用するには、TextFSM ライブラリーをインストールする必要があります。

en: Network XML filters
ja: ネットワーク XML フィルター

en: To convert the XML output of a network device command into structured JSON output, use the ``parse_xml`` filter::
ja: ネットワークデバイスコマンドの XML 出力を構造化された JSON 出力に変換するには、``parse_xml`` フィルターを使用します。

en: The ``parse_xml`` filter will load the spec file and pass the command output through formatted as JSON.
ja: ``parse_xml`` フィルターは、spec ファイルを読み込み、JSON としてフォーマットされたコマンド出力を渡します。

en: The spec file should be valid formatted YAML. It defines how to parse the XML output and return JSON data.
ja: 仕様ファイルは有効な YAML 形式である必要があります。XML 出力を解析し、JSON データを返す方法を定義します。

en: Below is an example of a valid spec file that will parse the output from the ``show vlan | display xml`` command.
ja: 以下は、``show vlan | display xml`` コマンドの出力を解析するための有効な spec ファイルの例です。

en: The same command could be parsed into a hash by using the key and values directives.  Here is an example of how to parse the output into a hash value using the same ``show vlan | display xml`` command.
ja: 同じコマンドでも、鍵と値のディレクティブを使用することで、ハッシュに解析することができます。以下は、同じ ``show vlan | display xml`` コマンドを使用して出力をハッシュ値に解析する例です。

en: The value of ``top`` is the XPath relative to the XML root node. In the example XML output given below, the value of ``top`` is ``configuration/vlans/vlan``, which is an XPath expression relative to the root node (<rpc-reply>). ``configuration`` in the value of ``top`` is the outer most container node, and ``vlan`` is the inner-most container node.
ja: ``top`` の値は、XML ルートノードに対する相対的な XPath です。以下の XML 出力例では、``top`` の値は ``configuration/vlans/vlan`` であり、これはルートノード (<rpc-reply>) に対する相対的な XPath 式です。``top`` の値の ``configuration`` は最も外側のコンテナーノードであり、``vlan`` は最も内側のコンテナーノードです。

en: ``items`` is a dictionary of key-value pairs that map user-defined names to XPath expressions that select elements. The Xpath expression is relative to the value of the XPath value contained in ``top``. For example, the ``vlan_id`` in the spec file is a user defined name and its value ``vlan-id`` is the relative to the value of XPath in ``top``
ja: ``items`` は、ユーザー定義の名前を、要素を選択する XPath 式にマッピングするキーと値のペアのディクショナリーです。Xpath 式は、``top`` に含まれる XPath 値の値に対する相対値です。たとえば、spec ファイルの ``vlan_id`` はユーザー定義の名前で、その値 ``vlan-id`` は、``top`` に含まれる XPath の値に対する相対値です。

en: Attributes of XML tags can be extracted using XPath expressions. The value of ``state`` in the spec is an XPath expression used to get the attributes of the ``vlan`` tag in output XML.::
ja: XML タグの属性は、XPath 式を用いて抽出することができます。仕様書の ``state`` の値は、出力された XML の ``vlan`` タグの属性を取得するために使用される XPath 式です。

en: For more information on supported XPath expressions, see `XPath Support <https://docs.python.org/2/library/xml.etree.elementtree.html#xpath-support>`_.
ja: サポートされる XPath 式の詳細は、「`XPath Support <https://docs.python.org/2/library/xml.etree.elementtree.html#xpath-support>`_」を参照してください。

en: Network VLAN filters
ja: ネットワーク VLAN フィルター

en: Use the ``vlan_parser`` filter to transform an unsorted list of VLAN integers into a sorted string list of integers according to IOS-like VLAN list rules. This list has the following properties:
ja: ``vlan_parser`` フィルターを使用して、ソートされていない VLAN 整数のリストを、IOS のような VLAN リストのルールに従ってソートされた整数の文字列リストに変換します。このリストには以下のプロパティーがあります。

en: Vlans are listed in ascending order.
ja: VLAN は昇順でリストされます。

en: Three or more consecutive VLANs are listed with a dash.
ja: 3 つ以上の連続した VLAN はダッシュ付きでリストされます。

en: The first line of the list can be first_line_len characters long.
ja: リストの最初の行は、first_line_len 文字の長さになります。

en: Subsequent list lines can be other_line_len characters.
ja: 後続のリスト行は、other_line_len 文字になります。

en: To sort a VLAN list::
ja: VLAN リストをソートするには、以下を実行します。

en: This example renders the following sorted list::
ja: この例では、以下のソートリストを示しています。

en: Another example Jinja template::
ja: Jinja テンプレートの他の例::

en: This allows for dynamic generation of VLAN lists on a Cisco IOS tagged interface. You can store an exhaustive raw list of the exact VLANs required for an interface and then compare that to the parsed IOS output that would actually be generated for the configuration.
ja: これにより、Cisco IOS タグ付きインターフェース上の VLAN リストを動的に生成することができます。インターフェースに必要な正確な VLAN の網羅的な生のリストを保存し、それを設定のために実際に生成されるであろう解析された IOS 出力と比較することができます。

en: Encrypting and checksumming strings and passwords
ja: 文字列およびパスワードの暗号化およびチェックサム

en: To get the sha1 hash of a string::
ja: 文字列の sha1 ハッシュを取得するには、次のようになります。

en: To get the md5 hash of a string::
ja: 文字列の md5 ハッシュを取得するには、次のようになります。

en: Get a string checksum::
ja: 文字列のチェックサムを取得します。

en: Other hashes (platform dependent)::
ja: その他のハッシュ (プラットフォームに依存)::

en: To get a sha512 password hash (random salt)::
ja: sha512 パスワードハッシュ (任意の salt) を取得するには、次のようになります。

en: To get a sha256 password hash with a specific salt::
ja: 特定の salt を持つ sha256 パスワードハッシュを取得するには、次のようになります。

en: An idempotent method to generate unique hashes per system is to use a salt that is consistent between runs::
ja: システムごとに一意のハッシュを生成する冪等な方法は、実行間で一貫性のある salt を使用することです。

en: Hash types available depend on the control system running Ansible, 'hash' depends on `hashlib <https://docs.python.org/3.8/library/hashlib.html>`_, password_hash depends on `passlib <https://passlib.readthedocs.io/en/stable/lib/passlib.hash.html>`_. The `crypt <https://docs.python.org/3.8/library/crypt.html>`_ is used as a fallback if ``passlib`` is not installed.
ja: 利用可能なハッシュタイプは、Ansible を実行している制御システムに依存しており、「hash」は `hashlib <https://docs.python.org/3.8/library/hashlib.html>`_ に、「password_hash」は `passlib <https://passlib.readthedocs.io/en/stable/lib/passlib.hash.html>`_ に依存しています。`crypt <https://docs.python.org/3.8/library/crypt.html>`_ は ``passlib`` がインストールされていない場合のフォールバックとして使用されます。

en: Some hash types allow providing a rounds parameter::
ja: ハッシュタイプによっては、rounds パラメーターを指定できるものもあります。

en: Manipulating text
ja: テキストの操作

en: Several filters work with text, including URLs, file names, and path names.
ja: いくつかのフィルターは、URL、ファイル名、パス名などのテキストを扱います。

en: Adding comments to files
ja: ファイルへのコメントの追加

en: The ``comment`` filter lets you create comments in a file from text in a template, with a variety of comment styles. By default Ansible uses ``#`` to start a comment line and adds a blank comment line above and below your comment text. For example the following::
ja: ``comment`` フィルターを使用すると、テンプレート内のテキストから、さまざまなコメントスタイルでファイル内にコメントを作成することができます。Ansible のデフォルトでは、``#`` を使用してコメント行を開始し、コメントテキストの上下に空白のコメント行を追加します。以下に例を示します。

en: produces this output:
ja: 次の出力を生成します。

en: Ansible offers styles for comments in C (``//...``), C block (``/*...*/``), Erlang (``%...``) and XML (``<!--...-->``)::
ja: Ansibleでは、C (``//...``)、C ブロック (``/*...*/``)、Erlang (``%...``)、および XML (``<!--...-->``) のコメント用スタイルを提供しています。

en: You can define a custom comment character. This filter::
ja: カスタムのコメント文字を定義できます。このフィルターは、以下のようになります。

en: produces:
ja: 生成:

en: You can fully customize the comment style::
ja: コメントスタイルを完全にカスタマイズすることもできます。

en: That creates the following output:
ja: これにより、以下の出力が作成されます。

en: The filter can also be applied to any Ansible variable. For example to make the output of the ``ansible_managed`` variable more readable, we can change the definition in the ``ansible.cfg`` file to this:
ja: フィルターは、Ansible 変数にも適用することもできます。たとえば、``ansible_managed`` 変数の出力をより読みやすくするために、``ansible.cfg`` ファイルの定義を以下のように変更します。

en: and then use the variable with the `comment` filter::
ja: 次に、`comment` フィルターで変数を使用します。

en: which produces this output:
ja: これは、次の出力を生成します。

en: URLEncode Variables
ja: URLEncode 変数

en: The ``urlencode`` filter quotes data for use in a URL path or query using UTF-8::
ja: ``urlencode`` フィルターは、URL パスを使用、または UTF-8 を使用したクエリーで使用するデータを引用します。

en: Splitting URLs
ja: URL の分割

en: The ``urlsplit`` filter extracts the fragment, hostname, netloc, password, path, port, query, scheme, and username from an URL. With no arguments, returns a dictionary of all the fields::
ja: ``urlsplit`` フィルターは、URL からフラグメント、ホスト名、netloc、パスワード、パス、ポート、クエリー、スキーム、およびユーザー名を抽出します。引数がない場合は、すべてのフィールドのディクショナリーを返します。

en: Searching strings with regular expressions
ja: 正規表現を使用した文字列の検索

en: To search in a string or extract parts of a string with a regular expression, use the ``regex_search`` filter::
ja: 文字列の検索または正規表現で文字列の部分を抽出するには、``regex_search`` フィルターを使用します。

en: To extract all occurrences of regex matches in a string, use the ``regex_findall`` filter::
ja: 文字列の中にある正規表現の一致のすべての出現箇所を抽出するには、``regex_findall`` フィルターを使用します。

en: To replace text in a string with regex, use the ``regex_replace`` filter::
ja: 文字列のテキストを正規表現に置き換えるには、``regex_replace`` フィルターを使用します。

en: If you want to match the whole string and you are using ``*`` make sure to always wraparound your regular expression with the start/end anchors. For example ``^(.*)$`` will always match only one result, while ``(.*)`` on some Python versions will match the whole string and an empty string at the end, which means it will make two replacements::
ja: 文字列全体に一致させたい場合に ``*`` を使用する場合は、必ず開始/終了アンカーで正規表現を折り返すようにしてください。たとえば、``^(.*)$`` は常に 1 つの結果のみに一致しますが、``(.*)`` はいくつかの Python バージョンでは文字列全体と最後に空の文字列に一致します。つまり 2 つの置換を行います。

en: Prior to ansible 2.0, if ``regex_replace`` filter was used with variables inside YAML arguments (as opposed to simpler 'key=value' arguments), then you needed to escape backreferences (for example, ``\\1``) with 4 backslashes (``\\\\``) instead of 2 (``\\``).
ja: ansible 2.0 より前のバージョンでは、(単純な「key=value」引数ではなく) ``regex_replace`` フィルターを YAML 引数内の変数に使用する場合は、後方参照 (たとえば ``\\1``) をバックスラッシュ 2 つ (``\\``) ではなく 4 つ (``\\\\``) でエスケープする必要がありました。

en: To escape special characters within a standard Python regex, use the ``regex_escape`` filter (using the default ``re_type='python'`` option)::
ja: 標準の Python 正規表現内で特殊文字をエスケープするには、``regex_escape`` フィルターを使用します (デフォルトの ``re_type='python'`` オプションを使用)。

en: To escape special characters within a POSIX basic regex, use the ``regex_escape`` filter with the ``re_type='posix_basic'`` option::
ja: POSIX 基本正規表現内で特殊文字をエスケープするには、``regex_escape`` フィルターを ``re_type='posix_basic'`` オプションを付けて使用します。

en: Managing file names and path names
ja: ファイル名とパス名の管理

en: To get the last name of a file path, like 'foo.txt' out of '/etc/asdf/foo.txt'::
ja: 「/etc/asdf/foo.txt」の「foo.txt」のように、ファイルパスの最後の名前を取得するには、以下を指定します。

en: To get the last name of a windows style file path (new in version 2.0)::
ja: ウィンドウスタイルのファイルパスの最後の名前を取得するには、以下を指定します (バージョン 2.0 の新機能)。

en: To separate the windows drive letter from the rest of a file path (new in version 2.0)::
ja: Windows ドライブの文字を残りのファイルパスから分離するには、以下を指定します (バージョン 2.0 の新機能)。

en: To get only the windows drive letter::
ja: Windows ドライブの文字のみを取得するには、以下を指定します。

en: To get the rest of the path without the drive letter::
ja: ドライブ文字なしで残りのパスを取得するには、以下を指定します。

en: To get the directory from a path::
ja: パスからディレクトリーを取得するには、以下を指定します。

en: To get the directory from a windows path (new version 2.0)::
ja: Windows パスからディレクトリーを取得するには、以下を指定します (バージョン 2.0 の新機能)。

en: To expand a path containing a tilde (`~`) character (new in version 1.5)::
ja: チルド (`~`) 文字を含むパスを拡張するには、以下を指定します (バージョン 1.5 の新機能)。

en: To expand a path containing environment variables::
ja: 環境変数を含むパスを拡張するには、以下を指定します。

en: `expandvars` expands local variables; using it on remote paths can lead to errors.
ja: `expandvars` は、ローカル変数を拡張します。リモートパスで使用するとエラーが発生する可能性があります。

en: To get the real path of a link (new in version 1.8)::
ja: リンクの実際のパスを取得するには、以下を指定します (バージョン 1.8 の新機能)。

en: To get the relative path of a link, from a start point (new in version 1.7)::
ja: リンクの相対パスを取得するには、開始点から以下を行います (バージョン 1.7 の新機能)。

en: To get the root and extension of a path or file name (new in version 2.0)::
ja: パスまたはファイル名のルートおよび拡張を取得するには、以下を指定します (バージョン 2.0 の新機能)。

en: The ``splitext`` filter always returns a pair of strings. The individual components can be accessed by using the ``first`` and ``last`` filters::
ja: ``splitext`` フィルターは、常に文字列のペアを返します。個々のコンポーネントは、``first`` フィルターおよび ``last`` フィルターを使用してアクセスできます。

en: To join one or more path components::
ja: 1 つ以上のパスコンポーネントを結合するには、以下を実行します。

en: Manipulating strings
ja: 文字列の操作

en: To add quotes for shell usage::
ja: シェルの使用に引用符を追加するには、以下を行います。

en: To concatenate a list into a string::
ja: リストを文字列に連結するには、以下を指定します。

en: To split a sting into a list::
ja: 文字列をリストに分割するには、以下を実行します。

en: To work with Base64 encoded strings::
ja: Base64 でエンコードされた文字列を使用するには、以下を指定します。

en: As of version 2.6, you can define the type of encoding to use, the default is ``utf-8``::
ja: バージョン 2.6 以降では、使用するエンコーディングのタイプを定義できます。デフォルトは ``utf-8`` です。

en: The ``string`` filter is only required for Python 2 and ensures that text to encode is a unicode string. Without that filter before b64encode the wrong value will be encoded.
ja: ``string`` フィルターは Python 2 でのみ必要です。エンコードするテキストがユニコード文字列であることを確認します。b64encode より前のフィルターを使用しないと、誤った値がエンコードされます。

en: Managing UUIDs
ja: UUID の管理

en: To create a namespaced UUIDv5::
ja: namespace を使用した UUIDv5 を作成するには、以下を実行します。

en: To create a namespaced UUIDv5 using the default Ansible namespace '361E6D51-FAEC-444A-9079-341386DA8E2E'::
ja: デフォルトの Ansible 名前空間「361E6D51-FAEC-444A-9079-341386DA8E2E2E」を使用して名前空間を指定した UUIDv5 を作成するには、以下を実行します。

en: To make use of one attribute from each item in a list of complex variables, use the :func:`Jinja2 map filter <jinja2:map>`::
ja: 複雑な変数のリストで、各項目から 1 つの属性を使用するには、:func:`Jinja2 map filter <jinja2:map>` を使用します。

en: Handling dates and times
ja: 日付と時刻の処理

en: To get a date object from a string use the `to_datetime` filter::
ja: 文字列から日付オブジェクトを取得するには、`to_datetime` フィルターを使用します。

en: For a full list of format codes for working with python date format strings, see https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior.
ja: Python 日付形式の文字列を使用する形式コードの全一覧は、https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior を参照してください。

en: To format a date using a string (like with the shell date command), use the "strftime" filter::
ja: 文字列 (shell date コマンドの場合のように) を使用して日付をフォーマットするには、「strftime」フィルターを使用します。

en: To get all string possibilities, check https://docs.python.org/3/library/time.html#time.strftime
ja: すべての文字列の可能性を取得するには、https://docs.python.org/3/library/time.html#time.strftime を確認します。

en: Getting Kubernetes resource names
ja: Kubernetes リソース名の取得

en: These filters have migrated to the `kuberernetes.core <https://galaxy.ansible.com/kubernetes/core>`_ collection. Follow the installation instructions to install that collection.
ja: これらのフィルターは `kuberernetes.core <https://galaxy.ansible.com/kubernetes/core>`_ コレクションに移行しました。インストール手順に従ってそのコレクションをインストールします。

en: Use the "k8s_config_resource_name" filter to obtain the name of a Kubernetes ConfigMap or Secret, including its hash::
ja: 「k8s_config_resource_name」フィルターを使用して、Kubernetes ConfigMap または Secret の名前を、そのハッシュを含めて取得します。

en: This can then be used to reference hashes in Pod specifications::
ja: これは、Pod 仕様のハッシュを参照するために使用できます。

en: Looping in playbooks
ja: Playbook でのループ

en: ipaddr filter
ja: ipaddr フィルター

en: ``ipaddr()`` is a Jinja2 filter designed to provide an interface to the `netaddr`_ Python package from within Ansible. It can operate on strings or lists of items, test various data to check if they are valid IP addresses, and manipulate the input data to extract requested information. ``ipaddr()`` works with both IPv4 and IPv6 addresses in various forms. There are also additional functions available to manipulate IP subnets and MAC addresses.
ja: ``ipaddr()`` は、`netaddr`_ Python パッケージへのインターフェースを Ansible 内から提供するように設計された Jinja2 フィルターです。文字列や項目のリストを操作したり、さまざまなデータが有効な IP アドレスであるかどうかをテストしたり、入力データを操作して要求された情報を抽出したりすることができます。``ipaddr()`` は、さまざまな形式の IPv4 と IPv6 の両方のアドレスを扱います。また、IP サブネットや MAC アドレスを操作するための追加機能も用意されています。

en: The ``ipaddr()`` filter migrated to the `ansible.netcommon <https://galaxy.ansible.com/ansible/netcommon>`_ collection. Follow the installation instructions to install that collection.
ja: ``ipaddr()`` フィルターは `ansible.netcommon <https://galaxy.ansible.com/ansible/netcommon>`_ コレクションに移行しました。インストール手順に従ってそのコレクションをインストールします。

en: To use this filter in Ansible, you need to install the `netaddr`_ Python library on a computer on which you use Ansible (it is not required on remote hosts). It can usually be installed with either your system package manager or using ``pip``::
ja: このフィルターを Ansible で使用するには、Ansible を使用するコンピューターに `netaddr`_ Python ライブラリーをインストールする必要があります (リモートホストでは必要ありません)。通常は、システムのパッケージマネージャーか、``pip`` を使用してインストールできます。

en: Topics
ja: トピック

en: Basic tests
ja: 基本的なテスト

en: ``ipaddr()`` is designed to return the input value if a query is True, and ``False`` if a query is False. This way it can be easily used in chained filters. To use the filter, pass a string to it:
ja: ``ipaddr()`` は、クエリーが True の場合は入力値を返し、False の場合は``False`` を返すように設計されています。これにより、連鎖したフィルターで簡単に使うことができます．このフィルターを使用するには、文字列を渡します。

en: You can also pass the values as variables::
ja: 変数として値を渡すこともできます。

en: Here are some example test results of various input strings::
ja: 以下は、さまざまな入力文字列のテスト結果の例です。

en: Sometimes you need either IPv4 or IPv6 addresses. To filter only for a particular type, ``ipaddr()`` filter has two "aliases", ``ipv4()`` and ``ipv6()``.
ja: IPv4 アドレスまたは IPv6 アドレスのいずれかが必要になる場合があります。特定のタイプに対してフィルターで絞り込むため、``ipaddr()`` フィルターには ``ipv4()`` と ``ipv6()`` という 2 つの「エイリアス」があります。

en: Example use of an IPv4 filter::
ja: IPv4 フィルターの使用例:

en: A similar example of an IPv6 filter::
ja: 同様の、IPv6 フィルターの使用例:

en: Here's some example test results to look for IPv4 addresses::
ja: 以下は、IPv4 アドレスを検索するテスト結果の例です。

en: And the same data filtered for IPv6 addresses::
ja: IPv6 アドレスにフィルターが設定されたデータ:

en: Filtering lists
ja: リストへのフィルター設定

en: You can filter entire lists - ``ipaddr()`` will return a list with values valid for a particular query::
ja: リスト全体にフィルターを設定できます。``ipaddr()`` は、特定のクエリーに有効な値を持つリストを返します。

en: Wrapping IPv6 addresses in [ ] brackets
ja: [ ] 括弧で IPv6 アドレスのラッピング

en: Some configuration files require IPv6 addresses to be "wrapped" in square brackets (``[ ]``). To accomplish that, you can use the ``ipwrap()`` filter. It will wrap all IPv6 addresses and leave any other strings intact::
ja: 一部の設定ファイルでは、IPv6 アドレスを角括弧 (``[ ]``) で「囲む」必要があります。これを行うには、``ipwrap()`` フィルターを使用することができます。これは、すべての IPv6 アドレスを囲み、その他の文字列はそのまま残します。

en: As you can see, ``ipwrap()`` did not filter out non-IP address values, which is usually what you want when for example you are mixing IP addresses with hostnames. If you still want to filter out all non-IP address values, you can chain both filters together::
ja: ご覧のように、``ipwrap()`` は、IP アドレス以外の値にフィルターを設定して除外していません。これは、IP アドレスとホスト名が混在している場合などに必要となるものです。それでもなお、IP アドレス以外のすべての値にフィルターを設定して除外したい場合は、両方のフィルターを連鎖させることができます。

en: Basic queries
ja: 基本クエリー

en: You can provide a single argument to each ``ipaddr()`` filter. The filter will then treat it as a query and return values modified by that query. Lists will contain only values that you are querying for.
ja: ``ipaddr()`` の各フィルターには、1 つの引数を指定することができます。フィルターはそれをクエリーとして扱い、そのクエリーで変更された値を返します。リストには、クエリーで指定した値のみが含まれます。

en: Types of queries include:
ja: クエリーの種類は次のとおりです。

en: query by name: ``ansible.netcommon.ipaddr('address')``, ``ansible.netcommon.ipv4('network')``;
ja: 名前によるクエリー: ``ansible.netcommon.ipaddr('address')``、``ansible.netcommon.ipv4('network')``

en: query by CIDR range: ``ansible.netcommon.ipaddr('192.168.0.0/24')``, ``ansible.netcommon.ipv6('2001:db8::/32')``;
ja: CIDR 範囲によるクエリー: ``ansible.netcommon.ipaddr('192.168.0.0/24')``、``ansible.netcommon.ipv6('2001:db8::/32')``

en: query by index number: ``ansible.netcommon.ipaddr('1')``, ``ansible.netcommon.ipaddr('-1')``;
ja: インデックス番号によるクエリー: ``ansible.netcommon.ipaddr('1')``、``ansible.netcommon.ipaddr('-1')``

en: If a query type is not recognized, Ansible will raise an error.
ja: クエリータイプが認識されないと、Ansible はエラーを発生させます。

en: Getting information about hosts and networks
ja: ホストおよびネットワークに関する情報の取得

en: Here's our test list again::
ja: ここでは、テストリストを再度使用します。

en: Let's take the list above and get only those elements that are host IP addresses and not network ranges::
ja: 上のリストから、ネットワーク範囲ではなくホスト IP アドレスの要素だけを取り出してみましょう。

en: As you can see, even though some values had a host address with a CIDR prefix, they were dropped by the filter. If you want host IP addresses with their correct CIDR prefixes (as is common with IPv6 addressing), you can use the ``ipaddr('host')`` filter::
ja: ご覧のように、CIDR プレフィックスを持つホストアドレスを持つ値があっても、フィルターによって破棄されています。正しい CIDR プレフィックスを持つホスト IP アドレスが必要な場合 (IPv6 アドレスでは一般的) は、``ipaddr('host')`` フィルターを使用できます。

en: Filtering by IP address type also works::
ja: IP アドレスタイプによるフィルタリングも機能します。

en: You can check if IP addresses or network ranges are accessible on a public Internet, or if they are in private networks::
ja: IP アドレスやネットワーク範囲が、パブリックなインターネット上でアクセス可能か、プライベートなネットワーク上にあるかどうかを確認することができます。

en: You can check which values are specifically network ranges::
ja: 特定のネットワーク範囲の値を確認できます。

en: You can also check how many IP addresses can be in a certain range::
ja: 特定の範囲内にある IP アドレスの数を確認することもできます。

en: By specifying a network range as a query, you can check if a given value is in that range::
ja: クエリーにネットワークの範囲を指定することで、指定した値がその範囲内にあるかどうかを調べることができます。

en: If you specify a positive or negative integer as a query, ``ipaddr()`` will treat this as an index and will return the specific IP address from a network range, in the 'host/prefix' format::
ja: 正または負の整数をクエリーとして指定すると、``ipaddr()`` はこれをインデックスとして扱い、ネットワークの範囲から特定の IP アドレスを「host/prefix」形式で返します。

en: You can also select IP addresses from a range by their index, from the start or end of the range::
ja: また、範囲内の IP アドレスを、範囲の最初または最後から、インデックスで選択することもできます。

en: Getting information from host/prefix values
ja: ホスト/プレフィックスの値からの情報の取得

en: You frequently use a combination of IP addresses and subnet prefixes ("CIDR"), this is even more common with IPv6. The ``ansible.netcommon.ipaddr()`` filter can extract useful data from these prefixes.
ja: IP アドレスとサブネットプレフィックス (「CIDR」) の組み合わせが頻繁に使用されます。これは IPv6 ではより一般的です。``ansible.netcommon.ipaddr()`` フィルターは、これらのプレフィックスから有用なデータを抽出できます。

en: Here's an example set of two host prefixes (with some "control" values)::
ja: 以下は、ホストプレフィックス (「制御」の値を含む) の例です。

en: First, let's make sure that we only work with correct host/prefix values, not just subnets or single IP addresses::
ja: まず、サブネットや単一の IP アドレスではなく、正しいホスト/プレフィックスの値のみを扱うことを確認しましょう。

en: In Debian-based systems, the network configuration stored in the ``/etc/network/interfaces`` file uses a combination of IP address, network address, netmask and broadcast address to configure an IPv4 network interface. We can get these values from a single 'host/prefix' combination:
ja: Debian ベースのシステムでは、``/etc/network/interfaces`` ファイルに保存されているネットワーク設定では、IP アドレス、ネットワークアドレス、ネットマスク、ブロードキャストアドレスの組み合わせを使用して、IPv4 ネットワークインターフェースを設定します。これらの値は、1つの「host/prefix」の組み合わせから得ることができます。

en: In the above example, we needed to handle the fact that values were stored in a list, which is unusual in IPv4 networks, where only a single IP address can be set on an interface. However, IPv6 networks can have multiple IP addresses set on an interface:
ja: 上の例では、値がリストに格納されていることを処理する必要がありました。これは、1 つのインターフェースに 1 つの IP アドレスしか設定できない IPv4 ネットワークでは珍しいことです。しかし、IPv6 ネットワークでは、1 つのインターフェースに複数の IP アドレスを設定することができます。

en: If needed, you can extract subnet and prefix information from the 'host/prefix' value:
ja: 必要な場合は、「host/prefix」値からサブネットおよびプレフィックス情報を抽出できます。

en: Converting subnet masks to CIDR notation
ja: サブネットマスクの CIDR 表記への変換

en: Given a subnet in the form of network address and subnet mask, the ``ipaddr()`` filter can convert it into CIDR notation.  This can be useful for converting Ansible facts gathered about network configuration from subnet masks into CIDR format::
ja: ネットワークアドレスとサブネットマスクの形式でサブネットが与えられると、``ipaddr()`` フィルターはそれを CIDR 表記に変換することができます。これは、サブネットマスクからネットワーク構成について収集した Ansible のファクトを CIDR 形式に変換する際に便利です。

en: First concatenate the network and netmask::
ja: 最初に、ネットワークとネットマスクを連結します。

en: This result can be converted to canonical form with ``ipaddr()`` to produce a subnet in CIDR format::
ja: これにより、``ipaddr()`` で正則形式に変換して、CIDR 形式でサブネットを生成できます。

en: Getting information about the network in CIDR notation
ja: CIDR 表記でのネットワーク情報の取得

en: Given an IP address, the ``ipaddr()`` filter can produce the network address in CIDR notation. This can be useful when you want to obtain the network address from the IP address in CIDR format.
ja: IP アドレスを指定すると、``ipaddr()`` フィルターは、CIDR 表記のネットワークアドレスを生成することができます。これは、CIDR 形式の IP アドレスからネットワークアドレスを取得したい場合に便利です。

en: Here's an example of IP address::
ja: 以下は IP アドレスの例です。

en: This can be used to obtain the network address in CIDR notation format::
ja: これは、CIDR 表記形式でネットワークアドレスを取得するのに使用できます。

en: IP address conversion
ja: IP アドレス変換

en: You can convert IPv4 addresses into IPv6 addresses::
ja: IPv4 アドレスを IPv6 アドレスに変換できます。

en: Converting from IPv6 to IPv4 works very rarely::
ja: IPv6 から IPv4 への変換はほとんど機能しません。

en: But we can make a double conversion if needed::
ja: ただし、必要に応じて二重変換を行うことができます。

en: You can convert IP addresses to integers, the same way that you can convert integers into IP addresses::
ja: 整数を IP アドレスに変換するのと同じ方法で、IP アドレスを整数に変換することができます。

en: You can convert IPv4 address to `Hexadecimal notation <https://en.wikipedia.org/wiki/Hexadecimal>`_ with optional delimiter::
ja: 任意の区切り文字を使用して、IPv4 アドレスを `16 進表記 <https://en.wikipedia.org/wiki/Hexadecimal>`_ に変換できます。

en: You can convert IP addresses to PTR records::
ja: IP アドレスを PTR レコードに変換できます。

en: Converting IPv4 address to a 6to4 address
ja: IPv4 アドレスの 6to4 アドレスへの変換

en: A `6to4`_ tunnel is a way to access the IPv6 Internet from an IPv4-only network. If you have a public IPv4 address, you can automatically configure its IPv6 equivalent in the ``2002::/16`` network range. After conversion you will gain access to a ``2002:xxxx:xxxx::/48`` subnet which could be split into 65535 ``/64`` subnets if needed.
ja: `6to4`_ トンネルは、IPv4 のみのネットワークから IPv6 インターネットにアクセスするための手段です。パブリック IPv4 アドレスがある場合は、その IPv6 相当のアドレスを ``2002::/16`` ネットワーク範囲内に自動的に設定することができます。変換後は、``2002:xxxx:xxxx::/48`` サブネットへのアクセスが可能になり、必要に応じて 65535 ``/64`` サブネットに分割することができます。

en: To convert your IPv4 address, just send it through the ``'6to4'`` filter. It will be automatically converted to a router address (with a ``::1/48`` host address)::
ja: IPv4 アドレスを変換するには、``'6to4'`` フィルターに通すだけです。自動的にルーターアドレス (ホストアドレスは ``::1/48``) に変換されます。

en: Finding IP addresses within a range
ja: 範囲内の IP アドレスの検索

en: To find usable IP addresses within an IP range, try these ``ipaddr`` filters:
ja: IP 範囲内で使用可能な IP アドレスを見つけるには、以下の ``ipaddr`` フィルターを試行します。

en: To find the next usable IP address in a range, use ``next_usable`` ::
ja: 範囲内の次の使用可能な IP アドレスを見つけるには、``next_usable`` を使用します。

en: To find the last usable IP address from a range, use ``last_usable``::
ja: 範囲から最後の使用可能な IP アドレスを見つけるには、``last_usable`` を使用します。

en: To find the available range of IP addresses from the given network address, use ``range_usable``::
ja: 指定したネットワークアドレスから利用可能な IP アドレスの範囲を検索するには、``range_usable`` を使用します。

en: To find the peer IP address for a point to point link, use ``peer``::
ja: ポイントツーポイントのリンクのピア IP アドレスを検索するには、``peer`` を使用します。

en: To return the nth ip from a network, use the filter ``nthhost``::
ja: ネットワークから nth ip に戻るには、フィルター ``nthhost`` を使用します。

en: ``nthhost`` also supports a negative value::
ja: ``nthhost`` は、負の値もサポートします。

en: To find the next nth usable IP address in relation to another within a range, use ``next_nth_usable`` In the example, ``next_nth_usable`` returns the second usable IP address for the given IP range::
ja: 範囲内の別の IP との関係で、次の n 番目に使用可能な IP アドレスを見つけるには、``next_nth_usable`` を使用します。この例では、``next_nth_usable`` が、指定の IP 範囲に 2 番目の使用可能な IP アドレスを返します。

en: If there is no usable address, it returns an empty string::
ja: 使用可能なアドレスがない場合は、空の文字列を返します。

en: Just like ``next_nth_ansible``, you have ``previous_nth_usable`` to find the previous usable address::
ja: ``next_nth_ansible`` と同様に ``previous_nth_usable`` があり、以前の使用可能なアドレスを見つけます。

en: Testing if a address belong to a network range
ja: アドレスがネットワーク範囲に属するかどうかのテスト

en: The ``network_in_usable`` filter returns whether an address passed as an argument is usable in a network. Usable addresses are addresses that can be assigned to a host. The network ID and the broadcast address are not usable addresses.::
ja: ``network_in_usable`` フィルターは、引数として渡されたアドレスがネットワーク上で使用可能かどうかを返します。使用可能なアドレスとは、ホストに割り当てることができるアドレスです。ネットワーク ID やブロードキャストアドレスは使用可能なアドレスではありません。

en: The ``network_in_network`` filter returns whether an address or a network passed as argument is in a network.::
ja: ``network_in_network`` フィルターは、引数として渡されたアドレスまたはネットワークがネットワーク内にあるかどうかを返します。

en: To check whether multiple addresses belong to a network, use the ``reduce_on_network`` filter::
ja: 複数のアドレスがネットワークに属するかどうかを確認するには、``reduce_on_network`` フィルターを使用します。

en: IP Math
ja: IP 計算

en: The ``ipmath()`` filter can be used to do simple IP math/arithmetic.
ja: ``ipmath()`` フィルターは、単純な IP 計算/演算をするのに使用できます。

en: Here are a few simple examples::
ja: 以下は簡単な例です。

en: Subnet manipulation
ja: サブネット操作

en: The ``ipsubnet()`` filter can be used to manipulate network subnets in several ways.
ja: ``ipsubnet()`` フィルターは、さまざまな方法でネットワークサブネットを操作するのに使用できます。

en: Here is an example IP address and subnet::
ja: IP アドレスとサブネットの例を以下に示します。

en: To check if a given string is a subnet, pass it through the filter without any arguments. If the given string is an IP address, it will be converted into a subnet::
ja: 特定の文字列がサブネットであるかどうかを確認するには、引数なしでフィルターを渡します。指定の文字列が IP アドレスの場合は、サブネットに変換されます。

en: If you specify a subnet size as the first parameter of the  ``ipsubnet()`` filter, and the subnet size is **smaller than the current one**, you will get the number of subnets a given subnet can be split into::
ja: ``ipsubnet()`` フィルターの最初のパラメーターにサブネットサイズを指定し、そのサブネットサイズが **現在のものより小さい場合**、指定されたサブネットが分割できるサブネットの数が得られます。

en: The second argument of the ``ipsubnet()`` filter is an index number; by specifying it you can get a new subnet with the specified size::
ja: ``ipsubnet()`` フィルターの第 2 引数はインデックス番号で、これを指定することで、指定したサイズの新しいサブネットを得ることができます。

en: If you specify an IP address instead of a subnet, and give a subnet size as the first argument, the ``ipsubnet()`` filter will instead return the biggest subnet that contains that given IP address::
ja: サブネットの代わりに IP アドレスを指定し、第 1 引数にサブネットサイズを指定した場合、``ipsubnet()`` フィルターは、代わりに指定された IP アドレスを含む最大のサブネットを返します。

en: By specifying an index number as a second argument, you can select smaller and smaller subnets::
ja: 第 2 引数にインデックス番号を指定することで、より小さなサブネットを選択することができます。

en: By specifying another subnet as a second argument, if the second subnet includes the first, you can determine the rank of the first subnet in the second ::
ja: 別のサブネットを 2 番目の引数として指定することで、2 番目のサブネットに最初のサブネットが含まれる場合は、2 番目のサブネットで最初のサブネットの順位を決定できます。

en: If the second subnet doesn't include the first subnet, the ``ipsubnet()`` filter raises an error.
ja: 2 つ目のサブネットに 1 つ目のサブネットが含まれていない場合、``ipsubnet()`` フィルターはエラーを出力します。

en: You can use the ``ipsubnet()`` filter with the ``ipaddr()`` filter to, for example, split a given ``/48`` prefix into smaller ``/64`` subnets::
ja: ``ipsubnet()`` フィルターと ``ipaddr()`` フィルターを併用することで、たとえば、``/48`` プレフィックスをより小さな ``/64`` サブネットに分割することができます。

en: Because of the size of IPv6 subnets, iteration over all of them to find the correct one may take some time on slower computers, depending on the size difference between the subnets.
ja: IPv6 サブネットはサイズが大きいため、正しいサブネットを見つけるためにすべてのサブネットを反復処理すると、遅いコンピューターではサブネット間のサイズ差に応じて時間がかかる場合があります。

en: Subnet Merging
ja: サブネットのマージ

en: The ``cidr_merge()`` filter can be used to merge subnets or individual addresses into their minimal representation, collapsing overlapping subnets and merging adjacent ones wherever possible::
ja: ``cidr_merge()`` フィルターは、サブネットや個々のアドレスを最小の表現に統合するために使用することができ、重複するサブネットを折りたたみ、可能な限り隣接するサブネットをマージすることができます。

en: Changing the action from 'merge' to 'span' will instead return the smallest subnet which contains all of the inputs::
ja: アクションを「merge」から「span」に変更すると、代わりに入力のすべてを含む最小のサブネットを返します。

en: MAC address filter
ja: MAC アドレスフィルター

en: You can use the ``hwaddr()`` filter to check if a given string is a MAC address or convert it between various formats. Examples::
ja: ``hwaddr()`` フィルターを使用して、与えられた文字列が MAC アドレスであるかどうかを確認したり、さまざまなフォーマット間で変換したりすることができます。以下に例を示します。

en: The supported formats result in the following conversions for the ``1a:2b:3c:4d:5e:6f`` MAC address::
ja: サポートされる形式により、以下の変換で、MAC アドレス ``1a:2b:3c:4d:5e:6f`` に対して、以下のような変換が行われます。

en: Generate an IPv6 address in Stateless Configuration (SLAAC)
ja: ステートレス設定 (SLAAC) で IPv6 アドレスを生成します。

en: the filter ``slaac()`` generates an IPv6 address for a given network and a MAC Address in Stateless Configuration::
ja: フィルター ``slaac()`` は、ステートレス設定の指定のネットワークおよび MAC アドレスに IPv6 アドレスを生成します。

en: Ansible network collection for common code
ja: 一般的なコードの Ansible ネットワークコレクション

en: Introduction to Jinja2 filters and their uses
ja: Jinja2 フィルターの概要およびその用途

en: Handlers: running operations on change
ja: ハンドラー: 変更時に実行する操作

en: Sometimes you want a task to run only when a change is made on a machine. For example, you may want to restart a service if a task updates the configuration of that service, but not if the configuration is unchanged. Ansible uses handlers to address this use case. Handlers are tasks that only run when notified. Each handler should have a globally unique name.
ja: マシンに変更が加えられたときにのみ、タスクを実行したい場合があります。たとえば、タスクがサービスの設定を更新した場合はサービスを再起動し、設定が変更していない場合には再起動しないようにしたい場合があります。Ansible では、このようなユースケースに対応するためにハンドラーを使用しています。ハンドラーは、通知されたときにのみ実行するタスクです。各ハンドラーには、グローバルに一意な名前を付ける必要があります。

en: Handler example
ja: ハンドラーの例

en: This playbook, ``verify-apache.yml``, contains a single play with a handler::
ja: この Playbook ``verify-apache.yml`` には、ハンドラーを使用した 1 つのプレイが含まれます。

en: In this example playbook, the second task notifies the handler. A single task can notify more than one handler::
ja: この Playbook の例では、2 番目のタスクがハンドラーに通知します。単一のタスクは複数のハンドラーに通知することができます。

en: Controlling when handlers run
ja: ハンドラーの実行時の制御

en: By default, handlers run after all the tasks in a particular play have been completed. This approach is efficient, because the handler only runs once, regardless of how many tasks notify it. For example, if multiple tasks update a configuration file and notify a handler to restart Apache, Ansible only bounces Apache once to avoid unnecessary restarts.
ja: デフォルトでは、ハンドラーは、特定のプレイにおけるすべてのタスクが完了した後に実行します。ハンドラーは、いくつのタスクが通知したかに関わらず、一度だけ実行するため、このアプローチは効率的です。たとえば、複数のタスクが設定ファイルを更新し、ハンドラーに Apache の再起動を通知した場合、Ansible は Apache を 1 回だけバウンスさせ、不要な再起動を回避します。

en: If you need handlers to run before the end of the play, add a task to flush them using the :ref:`meta module <meta_module>`, which executes Ansible actions::
ja: プレイの終了前にハンドラーを実行する必要がある場合は、Ansible アクションを実行する :ref:`meta module <meta_module>` を使用して、タスクをフラッシュします。

en: The ``meta: flush_handlers`` task triggers any handlers that have been notified at that point in the play.
ja: ``meta: flush_handlers`` タスクは、プレイのその時点で通知されたハンドラーを発生させます。

en: Using variables with handlers
ja: ハンドラーでの変数の使用

en: You may want your Ansible handlers to use variables. For example, if the name of a service varies slightly by distribution, you want your output to show the exact name of the restarted service for each target machine. Avoid placing variables in the name of the handler. Since handler names are templated early on, Ansible may not have a value available for a handler name like this::
ja: Ansible ハンドラーで変数を使用したい場合があります。たとえば、サービスの名前がディストリビューションによってわずかに異なる場合に、ターゲットマシンごとに再起動したサービスの正確な名前を出力するとします。ハンドラーの名前に変数を入れないでください。ハンドラー名は初期段階でテンプレート化されているため、Ansible では次のようなハンドラー名に利用できる値がない場合があります。

en: If the variable used in the handler name is not available, the entire play fails. Changing that variable mid-play **will not** result in newly created handler.
ja: ハンドラー名で使用される変数が利用できない場合は、プレイ全体が失敗します。変数 mid-play を変更すると、新しく作成されたハンドラーが **作成されません**。

en: Instead, place variables in the task parameters of your handler. You can load the values using ``include_vars`` like this:
ja: 代わりに、ハンドラーのタスクパラメーターに変数を配置します。以下のように ``include_vars`` を使用して、値を読み込むことができます。

en: Handlers can also "listen" to generic topics, and tasks can notify those topics as follows::
ja: ハンドラーは一般的なトピックを「リッスン」することもでき、タスクは次のようにそれらのトピックに通知できます。

en: This use makes it much easier to trigger multiple handlers. It also decouples handlers from their names, making it easier to share handlers among playbooks and roles (especially when using 3rd party roles from a shared source like Galaxy).
ja: これにより、複数のハンドラーを簡単に発生させることができます。また、ハンドラーを名前から切り離すことで、Playbook やロール間でのハンドラーの共有が容易になります (特に Galaxy のような共有ソースからサードパーティーのロールを使用する場合)。

en: Handlers always run in the order they are defined, not in the order listed in the notify-statement. This is also the case for handlers using `listen`.
ja: ハンドラーは、notify-statement に記載されている順番ではなく、常に定義されている順番で実行します。これは、`listen` を使用しているハンドラーにも当てはまります。

en: Handler names and `listen` topics live in a global namespace.
ja: ハンドラー名と `listen` トピックは、グローバルな名前空間にあります。

en: Handler names are templatable and `listen` topics are not.
ja: ハンドラー名は一時的なものですが、`listen` トピックは一時的ではありません。

en: Use unique handler names. If you trigger more than one handler with the same name, the first one(s) get overwritten. Only the last one defined will run.
ja: ハンドラーの名前は一意にしてください。同じ名前で複数のハンドラーを発生させる場合、最初のハンドラーは上書きされます。最後に定義されたものだけが実行されます。

en: You can notify a handler defined inside a static include.
ja: 静的インクルードの中で定義されたハンドラーを通知することができます。

en: You cannot notify a handler defined inside a dynamic include.
ja: 動的なインクルード内で定義されたハンドラーを通知することはできません。

en: A handler can not run import_role or include_role.
ja: ハンドラーは import_role または include_role を実行できません。

en: When using handlers within roles, note that:
ja: ロール内でハンドラーを使用する場合は、以下に注意してください。

en: handlers notified within ``pre_tasks``, ``tasks``, and ``post_tasks`` sections are automatically flushed at the end of section where they were notified.
ja: ``pre_tasks`` セクション、``tasks`` セクション、および ``post_tasks`` セクション内で通知されるハンドラーは、通知されたセクションの最後に自動的にフラッシュされます。

en: handlers notified within ``roles`` section are automatically flushed at the end of ``tasks`` section, but before any ``tasks`` handlers.
ja: ``roles``セクション内で通知されるハンドラーは、``tasks`` セクションの最後ではなく、``tasks`` ハンドラーの前に自動的にフラッシュされます。

en: handlers are play scoped and as such can be used outside of the role they are defined in.
ja: ハンドラーはスコープのあるプレイであるため、ハンドラーは定義されているロールの外で使用できます。

en: Intro to playbooks
ja: Playbook の概要

en: Ansible Playbooks offer a repeatable, re-usable, simple configuration management and multi-machine deployment system, one that is well suited to deploying complex applications. If you need to execute a task with Ansible more than once, write a playbook and put it under source control. Then you can use the playbook to push out new configuration or confirm the configuration of remote systems. The playbooks in the `ansible-examples repository <https://github.com/ansible/ansible-examples>`_ illustrate many useful techniques. You may want to look at these in another tab as you read the documentation.
ja: Ansible Playbook は、繰り返し使用可能で、再利用可能なシンプルな構成管理および複数マシンのデプロイメントシステムであり、複雑なアプリケーションのデプロイメントに適しています。Ansible で複数回タスクを実行する必要がある場合は、Playbook を作成してソースコントロール下に置きます。その後、Playbook を使用して、新しい設定をプッシュアウトしたり、リモートシステムの設定を確認したりすることができます。`ansible-examples リポジトリー <https://github.com/ansible/ansible-examples>`_ の Playbook には、多くの便利なテクニックが紹介されています。ドキュメントを読みながら、これらを別のタブで見てみるのもいいかもしれません。

en: Playbooks can:
ja: Playbook は、以下のことができます。

en: declare configurations
ja: 宣言設定

en: orchestrate steps of any manual ordered process, on multiple sets of machines, in a defined order
ja: 複数のマシンセットで、手動で順序付けされたプロセスの手順を定義された順序で編成します。

en: launch tasks synchronously or :ref:`asynchronously <playbooks_async>`
ja: タスクを同期または :ref:`非同期 <playbooks_async>` で起動

en: Playbook syntax
ja: Playbook 構文

en: Playbooks are expressed in YAML format with a minimum of syntax. If you are not familiar with YAML, look at our overview of :ref:`yaml_syntax` and consider installing an add-on for your text editor (see :ref:`other_tools_and_programs`) to help you write clean YAML syntax in your playbooks.
ja: Playbook は最小限の構文で YAML 形式で表現されます。YAML に慣れていない方は、:ref:`yaml_syntax` の概要を参照してください。また、Playbook にきれいな YAML 構文を書くために、テキストエディター用のアドオンのインストールを検討してください (「:ref:`other_tools_and_programs`」を参照)。

en: A playbook is composed of one or more 'plays' in an ordered list. The terms 'playbook' and 'play' are sports analogies. Each play executes part of the overall goal of the playbook, running one or more tasks. Each task calls an Ansible module.
ja: Playbook は、1 つまたは複数の「プレイ」を順番に並べたものです。「Playbook」と「プレイ」という言葉は、スポーツに例えられています。各プレイは、Playbook の全体的な目標の一部を実行し、1 つまたは複数のタスクを実行します。各タスクは、Ansible モジュールを呼び出します。

en: Playbook execution
ja: Playbook 実行

en: A playbook runs in order from top to bottom. Within each play, tasks also run in order from top to bottom. Playbooks with multiple 'plays' can orchestrate multi-machine deployments, running one play on your webservers, then another play on your database servers, then a third play on your network infrastructure, and so on. At a minimum, each play defines two things:
ja: Playbook は、上から下に向かって順番に実行されます。各プレイの中では、タスクも上から下の順に実行されます。複数の「プレイ」を持つ Playbook では、複数のマシンのデプロイメントを編成することができます。あるプレイを Web サーバーで実行した後、別のプレイをデータベースサーバーで実行し、さらに 3 つ目のプレイをネットワークインフラストラクチャーで実行するといった具合です。最低限、各プレイは 2 つのことを定義します。

en: the managed nodes to target, using a :ref:`pattern <intro_patterns>`
ja: :ref:`pattern <intro_patterns>`を使用する管理ノードが対象である

en: at least one task to execute
ja: 実行すべき 1 つ以上のタスク

en: In Ansible 2.10 and later, we recommend you use the fully-qualified collection name in your playbooks to ensure the correct module is selected, because multiple collections can contain modules with the same name (for example, ``user``). See :ref:`collections_using_playbook`.
ja: Ansible 2.10 以降では、複数のコレクションに同じ名前のモジュールが含まれていることがあるため (例: ``user``)、正しいモジュールが選択されるように、Playbook で完全修飾コレクション名を使用することが推奨されます。「:ref:`collections_using_playbook`」を参照してください。

en: In this example, the first play targets the web servers; the second play targets the database servers::
ja: この例では、第 1 のプレイは Web サーバーを対象とし、第 2 のプレイはデータベースサーバーを対象としています。

en: Your playbook can include more than just a hosts line and tasks. For example, the playbook above sets a ``remote_user`` for each play. This is the user account for the SSH connection. You can add other :ref:`playbook_keywords` at the playbook, play, or task level to influence how Ansible behaves. Playbook keywords can control the :ref:`connection plugin <connection_plugins>`, whether to use :ref:`privilege escalation <become>`, how to handle errors, and more. To support a variety of environments, Ansible lets you set many of these parameters as command-line flags, in your Ansible configuration, or in your inventory. Learning the :ref:`precedence rules <general_precedence_rules>` for these sources of data will help you as you expand your Ansible ecosystem.
ja: Playbook には、ホストラインとタスク以外の情報も含めることができます。たとえば、上記の Playbook では、各プレイに ``remote_user`` を設定しています。これは、SSH 接続用のユーザーアカウントです。Playbook、プレイ、またはタスクレベルで他の :ref:`playbook_keywords` を追加して、Ansible の動作に影響を与えることができます。Playbook のキーワードでは、:ref:`connection プラグイン <connection_plugins>` で、:ref:`特権昇格 <become>` を使用するかどうか、エラーをどのように処理するかなどを制御できます。さまざまな環境に対応するため、Ansible では、これらのパラメーターの多くをコマンドラインフラグ、Ansible の構成、またはインベントリーで設定することができます。これらのデータソースの :ref:`優先順位のルール <general_precedence_rules>` を学ぶことは、Ansible のエコシステムを拡張する際に役立ちます。

en: Task execution
ja: タスクの実行

en: By default, Ansible executes each task in order, one at a time, against all machines matched by the host pattern. Each task executes a module with specific arguments. When a task has executed on all target machines, Ansible moves on to the next task. You can use :ref:`strategies <playbooks_strategies>` to change this default behavior. Within each play, Ansible applies the same task directives to all hosts. If a task fails on a host, Ansible takes that host out of the rotation for the rest of the playbook.
ja: デフォルトでは、Ansible は、ホストパターンに一致するすべてのマシンに対して、各タスクを 1 つずつ順番に実行します。各タスクは、特定の引数を持つモジュールを実行します。タスクがすべてのターゲットマシンで実行すると、Ansible は次のタスクに移ります。このデフォルトの動作を変更するには、:ref:`ストラテジー <playbooks_strategies>` を使用します。各プレイの中で、Ansible は同じタスクディレクティブをすべてのホストに適用します。あるホストでタスクが失敗した場合、Ansible はそのホストを Playbook の残りの部分のローテーションから外します。

en: When you run a playbook, Ansible returns information about connections, the ``name`` lines of all your plays and tasks, whether each task has succeeded or failed on each machine, and whether each task has made a change on each machine. At the bottom of the playbook execution, Ansible provides a summary of the nodes that were targeted and how they performed. General failures and fatal "unreachable" communication attempts are kept separate in the counts.
ja: Playbook を実行すると、Ansible は接続に関する情報、すべてのプレイとタスクの ``name`` 行、各タスクが各マシンで成功したか失敗したか、および各タスクが各マシンで変更を行ったかどうかを返します。Playbook の実行の最後に、Ansible は、対象となったノードとそのパフォーマンスの概要を表示します。一般的な失敗と致命的な「到達不能」の通信試行は、カウントの中で分けて表示されます。

en: Desired state and 'idempotency'
ja: 希望の状態および「冪等性」

en: Most Ansible modules check whether the desired final state has already been achieved, and exit without performing any actions if that state has been achieved, so that repeating the task does not change the final state. Modules that behave this way are often called 'idempotent.' Whether you run a playbook once, or multiple times, the outcome should be the same. However, not all playbooks and not all modules behave this way. If you are unsure, test your playbooks in a sandbox environment before running them multiple times in production.
ja: ほとんどの Ansible モジュールは、目的の最終状態がすでに達成されているかどうかを確認し、その状態が達成されている場合は何も実行せずに終了するため、タスクを繰り返しても最終状態は変わりません。このような動作をするモジュールは、しばしば「冪等性」と呼ばれます。Playbook を 1 回だけ実行しても、複数回実行しても、結果は同じになるはずです。しかし、すべての Playbook やすべてのモジュールがこのように動作するわけではありません。不安な場合は、実稼働環境で Playbook を複数回実行する前に、サンドボックス環境で Playbook をテストしてください。

en: Running playbooks
ja: Playbook の実行

en: To run your playbook, use the :ref:`ansible-playbook` command::
ja: Playbook を実行するには、:ref:`ansible-playbook` コマンドを使用します。

en: Use the ``--verbose`` flag when running your playbook to see detailed output from successful modules as well as unsuccessful ones.
ja: 成功したモジュールと失敗したモジュールの詳細な出力を確認するには、Playbook の実行時に ``--verbose`` フラグを使用します。

en: Ansible-Pull
ja: ansible-pull

en: Should you want to invert the architecture of Ansible, so that nodes check in to a central location, instead of pushing configuration out to them, you can.
ja: ノードに設定をプッシュするのではなく、Ansible のアーキテクチャーを逆にして、ノードが中央の場所にチェックインするようにしたい場合は、以下を行うことができます。

en: The ``ansible-pull`` is a small script that will checkout a repo of configuration instructions from git, and then run ``ansible-playbook`` against that content.
ja: ``ansible-pull`` は小さなスクリプトで、git から設定方法をまとめたリポジトリーをチェックアウトし、その内容に対して ``ansible-playbook`` を実行します。

en: Assuming you load balance your checkout location, ``ansible-pull`` scales essentially infinitely.
ja: チェックアウトの場所を負荷分散する場合、``ansible-pull`` は基本的に無限にスケーリングを行います。

en: Run ``ansible-pull --help`` for details.
ja: 詳細は、「``ansible-pull --help``」を参照してください。

en: There's also a `clever playbook <https://github.com/ansible/ansible-examples/blob/master/language_features/ansible_pull.yml>`_ available to configure ``ansible-pull`` via a crontab from push mode.
ja: また、プッシュモードからの crontab で ``ansible-pull`` を設定する際に利用可能な `優れた Playbook <https://github.com/ansible/ansible-examples/blob/master/language_features/ansible_pull.yml>`_ もあります。

en: Verifying playbooks
ja: Playbook の検証

en: You may want to verify your playbooks to catch syntax errors and other problems before you run them. The :ref:`ansible-playbook` command offers several options for verification, including ``--check``, ``--diff``, ``--list-hosts``, ``--list-tasks``, and ``--syntax-check``. The :ref:`validate-playbook-tools` describes other tools for validating and testing playbooks.
ja: Playbook を実行する前に、構文エラーやその他の問題を検出するために、Playbook を検証したい場合があります。:ref:`ansible-playbook` コマンドには、``--check``、``--diff``、``--list-hosts``、``--list-tasks``、``--syntax-check`` など、検証のためのオプションが用意されています。「:ref:`validate-playbook-tools`」では、Playbook の検証とテストのための他のツールについて説明しています。

en: You can use `ansible-lint <https://docs.ansible.com/ansible-lint/index.html>`_ for detailed, Ansible-specific feedback on your playbooks before you execute them. For example, if you run ``ansible-lint`` on the playbook called ``verify-apache.yml`` near the top of this page, you should get the following results:
ja: `ansible-lint <https://docs.ansible.com/ansible-lint/index.html>`_ を使用すると、Playbook を実行する前に、Playbook に対する Ansible 固有の詳細なフィードバックを得ることができます。たとえば、このページの上位にある ``verify-apache.yml`` という Playbook に対して ``ansible-lint`` を実行すると、以下のような結果が得られます。

en: The `ansible-lint default rules <https://docs.ansible.com/ansible-lint/rules/default_rules.html>`_ page describes each error. For ``[403]``, the recommended fix is to change ``state: latest`` to ``state: present`` in the playbook.
ja: `ansible-lint デフォルトルール <https://docs.ansible.com/ansible-lint/rules/default_rules.html>`_ ページには、各エラーについて説明しています。``[403]`` については、Playbook で ``state: latest`` を ``state: present`` に変更することが推奨されます。

en: Learn how to test Ansible Playbooks syntax
ja: Ansible Playbook 構文のテスト方法について

en: Tips for managing playbooks in the real world
ja: 実際の Playbook の管理に関するさまざまなヒント

en: Learn to extend Ansible by writing your own modules
ja: 独自のモジュールを作成して Ansible を拡張する方法について

en: Complete end-to-end playbook examples
ja: 完全なエンドツーエンド Playbook の例

en: Lookups
ja: 検索 (lookup)

en: Lookup plugins retrieve data from outside sources such as files, databases, key/value stores, APIs, and other services. Like all templating, lookups execute and are evaluated on the Ansible control machine. Ansible makes the data returned by a lookup plugin available using the standard templating system. Before Ansible 2.5, lookups were mostly used indirectly in ``with_<lookup>`` constructs for looping. Starting with Ansible 2.5, lookups are used more explicitly as part of Jinja2 expressions fed into the ``loop`` keyword.
ja: lookup プラグインは、ファイル、データベース、キー/値ストア、API、その他のサービスなどの外部ソースからデータを取得します。すべてのテンプレート化と同様に、lookup は Ansible のコントロールマシン上で実行され、評価されます。Ansible では、lookup プラグインが返すデータを、標準のテンプレートシステムを使用して利用できるようにします。Ansible 2.5 以前、lookup はほとんどの場合、``with_<lookup>`` のループのための構成で間接的に使用されていました。Ansible 2.5 以降、lookup は Jinja2 の式の一部として、より明示的に使用されるようになり、``loop`` キーワードに供給されるようになりました。

en: Using lookups in variables
ja: 変数での lookup の使用

en: You can populate variables using lookups. Ansible evaluates the value each time it is executed in a task (or template)::
ja: lookup を使用して変数を設定することができます。Ansible は、タスク (またはテンプレート) で実行されるたびに値を評価します。

en: For more details and a list of lookup plugins in ansible-core, see :ref:`plugins_lookup`. You may also find lookup plugins in collections. You can review a list of lookup plugins installed on your control machine with the command ``ansible-doc -l -t lookup``.
ja: ansible-core の lookup プラグインの詳細と一覧は、「:ref:`plugins_lookup`」を参照してください。また、lookup プラグインはコレクションにも含まれています。コントロールマシンにインストールされている lookup プラグインのリストは、``ansible-doc -l -t lookup`` コマンドで確認できます。

en: Loops
ja: ループ

en: Ansible offers the ``loop``, ``with_<lookup>``, and ``until`` keywords to execute a task multiple times. Examples of commonly-used loops include changing ownership on several files and/or directories with the :ref:`file module <file_module>`, creating multiple users with the :ref:`user module <user_module>`, and repeating a polling step until a certain result is reached.
ja: Ansible には、``loop``、``with_<lookup>``、および ``until`` というキーワードがあり、1 つのタスクを複数回実行することができます。一般的に使用されるループの例としては、:ref:`file module <file_module>` で複数のファイルやディレクトリーの所有権を変更する、:ref:`user module <user_module>` で複数のユーザーを作成する、特定の結果が得られるまでポーリングステップを繰り返すなどがあります。

en: We added ``loop`` in Ansible 2.5. It is not yet a full replacement for ``with_<lookup>``, but we recommend it for most use cases.
ja: Ansible 2.5 で ``loop`` を追加しました。``with_<lookup>`` は完全に置き換えるものではありませんが、ほとんどのユースケースで推奨されています。

en: We have not deprecated the use of ``with_<lookup>`` - that syntax will still be valid for the foreseeable future.
ja: ``with_<lookup>`` の使用は非推奨になっていません。この構文は、今後も有効です。

en: We are looking to improve ``loop`` syntax - watch this page and the `changelog <https://github.com/ansible/ansible/tree/devel/changelogs>`_ for updates.
ja: ``loop`` 構文を改善する場合は、このページと `changelog <https://github.com/ansible/ansible/tree/devel/changelogs>`_ で更新を確認します。

en: Comparing ``loop`` and ``with_*``
ja: ``loop`` と ``with_*`` の比較

en: The ``with_<lookup>`` keywords rely on :ref:`lookup_plugins` - even  ``items`` is a lookup.
ja: ``with_<lookup>`` キーワードは :ref:`lookup_plugins` に依存し、``items`` も lookup となります。

en: The ``loop`` keyword is equivalent to ``with_list``, and is the best choice for simple loops.
ja: ``loop`` キーワードは ``with_list`` と同等であり、単純なループに最適です。

en: The ``loop`` keyword will not accept a string as input, see :ref:`query_vs_lookup`.
ja: ``loop`` キーワードは文字列を入力として受け付けません。「:ref:`query_vs_lookup`」を参照してください。

en: Generally speaking, any use of ``with_*`` covered in :ref:`migrating_to_loop` can be updated to use ``loop``.
ja: 通常、「:ref:`migrating_to_loop`」で対応している ``with_*`` を使用すると、``loop`` を使用するように更新できます。

en: Be careful when changing ``with_items`` to ``loop``, as ``with_items`` performed implicit single-level flattening. You may need to use ``flatten(1)`` with ``loop`` to match the exact outcome. For example, to get the same output as:
ja: ``with_items`` を ``loop`` に変更する際には、``with_items`` が暗黙の単一レベルのフラット化を行うため注意が必要です。正確な結果を得るためには、``flatten(1)`` と ``loop`` の併用が必要になる可能性があります。たとえば、次と同じ出力を得るには、

en: you would need::
ja: 以下が必要です。

en: Any ``with_*`` statement that requires using ``lookup`` within a loop should not be converted to use the ``loop`` keyword. For example, instead of doing:
ja: ループ内で ``lookup`` を使用する必要のある ``with_*`` 文は、``loop`` キーワードを使用するように変換しないでください。たとえば、代わりに、以下を行います。

en: it's cleaner to keep::
ja: 保持する方が見た目がすっきりします。

en: Standard loops
ja: 標準ループ

en: Iterating over a simple list
ja: シンプルなリストでの反復

en: Repeated tasks can be written as standard loops over a simple list of strings. You can define the list directly in the task::
ja: 繰り返されるタスクは、文字列の単純なリストに対する標準的なループとして記述できます。このリストはタスクの中で直接定義できます。

en: You can define the list in a variables file, or in the 'vars' section of your play, then refer to the name of the list in the task::
ja: 変数ファイルでリストを定義するか、プレイの「vars」セクションで、タスク内のリストの名前を参照します。

en: Either of these examples would be the equivalent of::
ja: これらの例のいずれも、以下と同等です。

en: You can pass a list directly to a parameter for some plugins. Most of the packaging modules, like :ref:`yum <yum_module>` and :ref:`apt <apt_module>`, have this capability. When available, passing the list to a parameter is better than looping over the task. For example::
ja: いくつかのプラグインでは、パラメーターにリストを直接渡すことができます。:ref:`yum <yum_module>` や :ref:`apt <apt_module>` など、ほとんどのパッケージングモジュールにこの機能があります。利用できる場合は、リストをパラメーターに渡す方が、タスクをループさせるよりも良いでしょう。以下に例を示します。

en: Check the :ref:`module documentation <modules_by_category>` to see if you can pass a list to any particular module's parameter(s).
ja: :ref:`モジュールのドキュメント <modules_by_category>` で、特定モジュールのパラメーターにリストを渡すことができるかどうかを確認します。

en: Iterating over a list of hashes
ja: ハッシュリストでの反復

en: If you have a list of hashes, you can reference subkeys in a loop. For example::
ja: ハッシュリストがある場合は、ループでサブキーを参照できます。以下に例を示します。

en: When combining :ref:`conditionals <playbooks_conditionals>` with a loop, the ``when:`` statement is processed separately for each item. See :ref:`the_when_statement` for examples.
ja: :ref:`conditionals <playbooks_conditionals>` とループを組み合わせると、``when:`` 文は各項目について個別に処理されます。例は「:ref:`the_when_statement`」を参照してください。

en: Iterating over a dictionary
ja: ディクショナリーでの反復

en: To loop over a dict, use the  :ref:`dict2items <dict_filter>`:
ja: ディクショナリーでループするには、:ref:`dict2items <dict_filter>` を使用します。

en: Here, we are iterating over `tag_data` and printing the key and the value from it.
ja: ここでは、`tag_data` を繰り返し処理し、キーと値を出力します。

en: Registering variables with a loop
ja: ループによる変数の登録

en: You can register the output of a loop as a variable. For example::
ja: ループの出力を変数として登録できます。たとえば、次のようになります。

en: When you use ``register`` with a loop, the data structure placed in the variable will contain a ``results`` attribute that is a list of all responses from the module. This differs from the data structure returned when using ``register`` without a loop::
ja: ``register`` をループで使用すると、変数に配置されるデータ構造には、モジュールからのすべての応答のリストである ``results`` 属性が含まれます。これは、``register`` をループなしで使用したときに返されるデータ構造とは異なります。

en: Subsequent loops over the registered variable to inspect the results may look like::
ja: 登録済みの変数で後続のループを実行して結果を検査すると、以下のようになります。

en: During iteration, the result of the current item will be placed in the variable::
ja: 反復時に、現在の項目の結果は変数に配置されます。

en: Complex loops
ja: 複雑なループ

en: Iterating over nested lists
ja: 入れ子のリストでの反復

en: You can use Jinja2 expressions to iterate over complex lists. For example, a loop can combine nested lists::
ja: Jinja2 の式を使用して、複雑なリストを繰り返し処理することができます。たとえば、ループは入れ子になったリストを組み合わせることができます。

en: Retrying a task until a condition is met
ja: 条件が満たされるまでタスクの再試行

en: You can use the ``until`` keyword to retry a task until a certain condition is met.  Here's an example::
ja: ``until`` キーワードを使用すると、ある条件が満たされるまでタスクを再試行することができます。以下に例を示します。

en: This task runs up to 5 times with a delay of 10 seconds between each attempt. If the result of any attempt has "all systems go" in its stdout, the task succeeds. The default value for "retries" is 3 and "delay" is 5.
ja: このタスクは、各試行の間に 10 秒の遅延を置いて最大 5 回実行される。試行の結果、標準出力に「all systems go」と表示されていれば、タスクは成功です。「retries (再試行)」のデフォルト値は 3、「delay (遅延)」は 5 です。

en: To see the results of individual retries, run the play with ``-vv``.
ja: 個別の再試行の結果を表示するには、``-vv`` でプレイを実行します。

en: When you run a task with ``until`` and register the result as a variable, the registered variable will include a key called "attempts", which records the number of the retries for the task.
ja: ``until`` を使用してタスクを実行し、結果を変数として登録する場合は、登録済み変数には「attempts」と呼ばれる鍵が含まれ、タスクの再試行回数を記録します。

en: You must set the ``until`` parameter if you want a task to retry. If ``until`` is not defined, the value for the ``retries`` parameter is forced to 1.
ja: タスクが再試行するには、``until`` パラメーターを設定する必要があります。``until`` が定義されていない場合は、``retries`` パラメーターの値が 1 に強制されます。

en: Looping over inventory
ja: インベントリーのループ

en: To loop over your inventory, or just a subset of it, you can use a regular ``loop`` with the ``ansible_play_batch`` or ``groups`` variables::
ja: インベントリーやその一部だけをループさせるには、通常の ``loop`` に ``ansible_play_batch`` 変数や ``groups`` 変数を加えたものを使用することができます。

en: There is also a specific lookup plugin ``inventory_hostnames`` that can be used like this::
ja: また、以下のような特定の lookup プラグイン ``inventory_hostnames`` も使用できます。

en: More information on the patterns can be found in :ref:`intro_patterns`.
ja: パターンの詳細は、「:ref:`intro_patterns`」を参照してください。

en: Ensuring list input for ``loop``: using ``query`` rather than ``lookup``
ja: ``loop`` のリスト入力の確保: ``lookup`` の代わりに ``query`` を使用

en: The ``loop`` keyword requires a list as input, but the ``lookup`` keyword returns a string of comma-separated values by default. Ansible 2.5 introduced a new Jinja2 function named :ref:`query <query>` that always returns a list, offering a simpler interface and more predictable output from lookup plugins when using the ``loop`` keyword.
ja: ``loop`` キーワードは入力としてリストを必要としますが、``lookup`` キーワードはデフォルトでコンマで区切られた値の文字列を返すようになっています。Ansible 2.5 では、:ref:`query <query>` という名前の新しい Jinja2 関数が導入され、常にリストを返すようになりました。これにより、インターフェースがシンプルになり、``loop`` キーワードを使用した場合の lookup プラグインの出力がより予測しやすくなりました。

en: You can force ``lookup`` to return a list to ``loop`` by using ``wantlist=True``, or you can use ``query`` instead.
ja: ``wantlist=True`` を使用すれば、``lookup`` がリストを ``loop`` に返すように強制したり、代わりに ``query`` を使用することもできます。

en: These examples do the same thing::
ja: これらの例では、以下を行います。

en: Adding controls to loops
ja: ループへのコントロールの追加

en: The ``loop_control`` keyword lets you manage your loops in useful ways.
ja: ``loop_control`` キーワードを使用すると、ループを便利な方法で管理できます。

en: Limiting loop output with ``label``
ja: ``label`` を使用したループ出力の制限

en: When looping over complex data structures, the console output of your task can be enormous. To limit the displayed output, use the ``label`` directive with ``loop_control``::
ja: 複雑なデータ構造をループしていると、タスクのコンソール出力が膨大になることがあります。表示される出力を制限するには、``label`` ディレクティブと ``loop_control`` を使用します。

en: The output of this task will display just the ``name`` field for each ``item`` instead of the entire contents of the multi-line ``{{ item }}`` variable.
ja: このタスクの出力には、複数行の ``{{ item }}`` 変数の内容全体ではなく、各 ``item`` の ``name`` フィールドのみが表示されます。

en: This is for making console output more readable, not protecting sensitive data. If there is sensitive data in ``loop``, set ``no_log: yes`` on the task to prevent disclosure.
ja: これはコンソール出力を読みやすくするためのもので、機密データを保護するものではありません。``loop`` に機密データがある場合は、``no_log: yes`` をタスクに設定して漏洩を防ぎます。

en: Pausing within a loop
ja: ループ内での一時停止

en: To control the time (in seconds) between the execution of each item in a task loop, use the ``pause`` directive with ``loop_control``::
ja: タスクループの各項目の実行間隔を (秒単位) で制御するには、``pause`` で ``loop_control`` ディレクティブを使用します。

en: Tracking progress through a loop with ``index_var``
ja: ``index_var`` のあるループでの進捗の追跡

en: To keep track of where you are in a loop, use the ``index_var`` directive with ``loop_control``. This directive specifies a variable name to contain the current loop index::
ja: ループ内のどこにいるかを把握するには、``loop_control`` とともに ``index_var`` ディレクティブを使用します。このディレクティブは、現在のループのインデックスを格納する変数名を指定します。

en: `index_var` is 0 indexed.
ja: `index_var` は、0 インデックスです。

en: Defining inner and outer variable names with ``loop_var``
ja: ``loop_var`` を使用した内部変数名および外部変数名の定義

en: You can nest two looping tasks using ``include_tasks``. However, by default Ansible sets the loop variable ``item`` for each loop. This means the inner, nested loop will overwrite the value of ``item`` from the outer loop. You can specify the name of the variable for each loop using ``loop_var`` with ``loop_control``::
ja: ``include_tasks`` を使用すると、2 つのループタスクを入れ子にすることができます。ただし、Ansible のデフォルトでは、ループごとにループ変数 ``item`` が設定されます。これは、入れ子になった内側のループが、外側のループの ``item`` の値を上書きすることを意味します。``loop_var`` と ``loop_control`` を使用して、各ループの変数名を指定することができます。

en: If Ansible detects that the current loop is using a variable which has already been defined, it will raise an error to fail the task.
ja: 定義されている変数を現在のループが使用していることを Ansible が検出すると、タスクが失敗するためにエラーが発生します。

en: Extended loop variables
ja: 拡張ループ変数

en: As of Ansible 2.8 you can get extended loop information using the ``extended`` option to loop control. This option will expose the following information.
ja: Ansible 2.8 では、ループ制御に ``extended`` オプションを使用することで、拡張されたループ情報を得ることができます。このオプションは、以下の情報を公開します。

en: Variable
ja: 変数

en: The list of all items in the loop
ja: ループ内のすべての項目のリスト

en: The current iteration of the loop. (1 indexed)
ja: ループの現在の反復 (1 インデックス化)

en: The current iteration of the loop. (0 indexed)
ja: ループの現在の反復 (0 インデックス化)

en: The number of iterations from the end of the loop (1 indexed)
ja: ループの最後からの反復回数 (1 インデックス化)

en: The number of iterations from the end of the loop (0 indexed)
ja: ループの最後からの反復回数 (0 インデックス化)

en: ``True`` if first iteration
ja: 最初の反復の場合は ``True``

en: ``True`` if last iteration
ja: 最後の反復の場合は ``True``

en: The number of items in the loop
ja: ループ内の項目数

en: The item from the previous iteration of the loop. Undefined during the first iteration.
ja: ループの前の反復の項目。最初の反復では未定義です。

en: The item from the following iteration of the loop. Undefined during the last iteration.
ja: ループの次の反復の項目。最初の反復では未定義です。

en: Accessing the name of your loop_var
ja: loop_var の名前へのアクセス

en: As of Ansible 2.8 you can get the name of the value provided to ``loop_control.loop_var`` using the ``ansible_loop_var`` variable
ja: Ansible 2.8 では、``ansible_loop_var`` 変数を使用して ``loop_control.loop_var`` に提供された値の名前を取得できます。

en: For role authors, writing roles that allow loops, instead of dictating the required ``loop_var`` value, you can gather the value via::
ja: ロールの作成者は、必要な ``loop_var`` 値を指定する代わりに、ループを許可するロールを作成することで、次の方法で値を収集できます。

en: Migrating from with_X to loop
ja: with_X から loop への移行

en: In most cases, loops work best with the ``loop`` keyword instead of ``with_X`` style loops. The ``loop`` syntax is usually best expressed using filters instead of more complex use of ``query`` or ``lookup``.
ja: ほとんどの場合、ループは、``with_X`` スタイルのループではなく、``loop`` キーワードで最適に機能します。``loop`` 構文は通常、``query`` や ``lookup`` の複雑な使用ではなく、フィルターを使用して表現できます。

en: These examples show how to convert many common ``with_`` style loops to ``loop`` and filters.
ja: 以下の例では、一般的な ``with_`` スタイルのループを ``loop`` およびフィルターに変換する方法を示しています。

en: ``with_list`` is directly replaced by ``loop``.
ja: ``with_list`` は、直接 ``loop`` に置き換えられました。

en: ``with_items`` is replaced by ``loop`` and the ``flatten`` filter.
ja: ``with_items`` は、``loop`` および ``flatten`` フィルターに置き換えられました。

en: ``with_indexed_items`` is replaced by ``loop``, the ``flatten`` filter and ``loop_control.index_var``.
ja: ``with_indexed_items`` は、``loop``、``flatten`` フィルター、および ``loop_control.index_var`` に置き換えられました。

en: ``with_flattened`` is replaced by ``loop`` and the ``flatten`` filter.
ja: ``with_flattened`` は、``loop`` および ``flatten`` フィルターに置き換えられました。

en: ``with_together`` is replaced by ``loop`` and the ``zip`` filter.
ja: ``with_together`` は、``loop`` および ``zip`` フィルターに置き換えられました。

en: Another example with complex data
ja: 複雑なデータがある別の例

en: ``with_dict`` can be substituted by ``loop`` and either the ``dictsort`` or ``dict2items`` filters.
ja: ``with_dict`` は、``loop`` と、``dictsort`` または``dict2items`` のいずれかのフィルターに置き換えられました。

en: ``with_sequence`` is replaced by ``loop`` and the ``range`` function, and potentially the ``format`` filter.
ja: ``with_sequence`` は、``loop`` と``range`` の関数、そして潜在的には``format`` フィルターに置き換えられました。

en: ``with_subelements`` is replaced by ``loop`` and the ``subelements`` filter.
ja: ``with_subelements`` は、``loop`` および ``subelements`` フィルターに置き換えられました。

en: ``with_nested`` and ``with_cartesian`` are replaced by loop and the ``product`` filter.
ja: ``with_nested`` と``with_cartesian`` は、ループと ``product`` のフィルターに置き換えられました。

en: ``with_random_choice`` is replaced by just use of the ``random`` filter, without need of ``loop``.
ja: ``with_random_choice`` は、``random`` フィルターを使用するだけで、``loop`` を必要とせずに置き換えることができます。

en: Module defaults
ja: モジュールのデフォルト

en: If you frequently call the same module with the same arguments, it can be useful to define default arguments for that particular module using the ``module_defaults`` keyword.
ja: 同じ引数で同じモジュールを頻繁に呼び出す場合は、``module_defaults`` キーワードを使用して、その特定のモジュールのデフォルト引数を定義すると便利です。

en: Here is a basic example::
ja: 以下に基本的な例を示します。

en: The ``module_defaults`` keyword can be used at the play, block, and task level. Any module arguments explicitly specified in a task will override any established default for that module argument::
ja: ``module_defaults`` キーワードは、プレイ、ブロック、およびタスクレベルで使用できます。タスクで明示的に指定されたモジュール引数は、そのモジュール引数に対して確立されたデフォルトを上書きします。

en: You can remove any previously established defaults for a module by specifying an empty dict::
ja: 空のディクショナリーを指定することで、それまでに設定されたモジュールのデフォルトを削除することができます。

en: Any module defaults set at the play level (and block/task level when using ``include_role`` or ``import_role``) will apply to any roles used, which may cause unexpected behavior in the role.
ja: プレイレベルで設定されるモジュールのデフォルト (``include_role`` または ``import_role`` を使用する際のブロックまたはタスクのレベル) は、使用されるロールに適用されます。これにより、ロールで予期しない動作が発生する可能性があります。

en: Here are some more realistic use cases for this feature.
ja: この機能のより実用的なユースケースを以下に示します。

en: Interacting with an API that requires auth::
ja: 認証をを必要とする API との対話:

en: Setting a default AWS region for specific EC2-related modules::
ja: 特定の EC2 関連のモジュールにデフォルトの AWS リージョンを設定します。

en: Module defaults groups
ja: モジュールのデフォルトグループ

en: Ansible 2.7 adds a preview-status feature to group together modules that share common sets of parameters. This makes it easier to author playbooks making heavy use of API-based modules such as cloud modules.
ja: Ansible 2.7 では、共通のパラメーターセットを持つモジュールをまとめて表示するプレビューステータス機能が追加されました。これにより、クラウドモジュールなどの API ベースのモジュールを多用する Playbook の作成が容易になります。

en: Group
ja: グループ

en: Purpose
ja: 目的

en: Ansible Version
ja: Ansible バージョン

en: The `docker_stack <docker_stack_module>`_ module is not included in the ``docker`` defaults group.
ja: `docker_stack <docker_stack_module>`_ モジュールは、``docker`` デフォルトグループには含まれません。

en: Use the groups with ``module_defaults`` by prefixing the group name with ``group/`` - for example ``group/aws``.
ja: グループ名の前に ``group/`` を追加して (例: ``group/aws``)、``module_defaults`` でグループを使用します。

en: In a playbook, you can set module defaults for whole groups of modules, such as setting a common AWS region.
ja: Playbook では、一般的な AWS リージョンの設定など、モジュールのグループ全体にモジュールのデフォルトを設定できます。

en: Interactive input: prompts
ja: インタラクティブな入力: prompt

en: If you want your playbook to prompt the user for certain input, add a 'vars_prompt' section. Prompting the user for variables lets you avoid recording sensitive data like passwords. In addition to security, prompts support flexibility. For example, if you use one playbook across multiple software releases, you could prompt for the particular release version.
ja: Playbook でユーザーに特定の入力を促したい場合は、「vars_prompt」セクションを追加します。ユーザーに変数の入力を促すことで、パスワードのような機密データの記録を回避することができます。セキュリティーのほかに、プロンプトは柔軟性をサポートします。たとえば、1 つの Playbook を複数のソフトウェアリリースで使用する場合は、特定のリリースバージョンの入力を促すことができます。

en: Here is a most basic example::
ja: 以下は最も基本的な例です。

en: The user input is hidden by default but it can be made visible by setting ``private: no``.
ja: ユーザー入力はデフォルトでは表示されませんが、``private: no`` を設定することで表示できます。

en: Prompts for individual ``vars_prompt`` variables will be skipped for any variable that is already defined through the command line ``--extra-vars`` option, or when running from a non-interactive session (such as cron or Ansible Tower). See :ref:`passing_variables_on_the_command_line`.
ja: 個別の ``vars_prompt`` 変数の入力を求めるプロンプトは、コマンドラインの ``--extra-vars`` オプションですでに定義されている変数や、非対話的なセッション (cron や Ansible Tower など) から実行する場合に省略されます。「:ref:`passing_variables_on_the_command_line`」を参照してください。

en: If you have a variable that changes infrequently, you can provide a default value that can be overridden::
ja: まれに変更する変数がある場合は、上書きできるデフォルト値を指定できます。

en: Encrypting values supplied by ``vars_prompt``
ja: ``vars_prompt`` により提供される値の暗号化

en: You can encrypt the entered value so you can use it, for instance, with the user module to define a password::
ja: 入力値を暗号化して、たとえばユーザーモジュールを使用してパスワードを定義できます。

en: If you have `Passlib <https://passlib.readthedocs.io/en/stable/>`_ installed, you can use any crypt scheme the library supports:
ja: `Passlib <https://passlib.readthedocs.io/en/stable/>`_ をインストールしている場合は、ライブラリーがサポートする任意の crypt スキームを使用できます。

en: *bsd_nthash* - FreeBSD's MCF-compatible nthash encoding
ja: *bsd_nthash* - FreeBSD's MCF 互換の nthash エンコーディング

en: The only parameters accepted are 'salt' or 'salt_size'. You can use your own salt by defining 'salt', or have one generated automatically using 'salt_size'. By default Ansible generates a salt of size 8.
ja: 使用できるパラメーターは「salt」または「salt_size」のみです。「salt」を定義して独自のソルトを使用することも、「salt_size」を使用して自動的に生成されるソルトを使用することもできます。デフォルトでは、Ansible はサイズ 8 の salt を生成します。

en: If you do not have Passlib installed, Ansible uses the `crypt <https://docs.python.org/2/library/crypt.html>`_ library as a fallback. Ansible supports at most four crypt schemes, depending on your platform at most the following crypt schemes are supported:
ja: Passlib がインストールされていない場合、Ansible はフォールバックとして `crypt <https://docs.python.org/2/library/crypt.html>`_ ライブラリーを使用します。Ansible は最大で 4 つの暗号方式をサポートしていますが、プラットフォームによっては最大で以下の暗号方式をサポートしています。

en: Allowing special characters in ``vars_prompt`` values
ja: ``vars_prompt`` 値での特殊文字の許可

en: Some special characters, such as ``{`` and ``%`` can create templating errors. If you need to accept special characters, use the ``unsafe`` option::
ja: ``{`` や ``%`` などの特殊文字は、テンプレートエラーの作成が可能です。特殊文字を受け入れる必要がある場合は、``unsafe`` オプションを使用します。

en: Python3 in templates
ja: テンプレート内の Python3

en: Ansible uses Jinja2 to leverage Python data types and standard functions in templates and variables. You can use these data types and standard functions to perform a rich set of operations on your data. However, if you use templates, you must be aware of differences between Python versions.
ja: Ansible は Jinja2 を使用して、テンプレートや変数に Python のデータ型や標準関数を活用しています。これらのデータ型や標準関数を利用することで、データに対して豊富な操作を行うことができます。ただし、テンプレートを使用する場合は、Python のバージョンによる違いに注意する必要があります。

en: These topics help you design templates that work on both Python2 and Python3. They might also help if you are upgrading from Python2 to Python3. Upgrading within Python2 or Python3 does not usually introduce changes that affect Jinja2 templates.
ja: これらのトピックは、Python2 と Python3 の両方で動作するテンプレートをデザインするのに役立ちます。また、Python2 から Python3 へのアップグレードの際にも役立つでしょう。Python2 や Python3 にアップグレードしても、通常は Jinja2 のテンプレートに影響を与えるような変更はありません。

en: Dictionary views
ja: ディクショナリービュー

en: In Python2, the :meth:`dict.keys`, :meth:`dict.values`, and :meth:`dict.items` methods return a list.  Jinja2 returns that to Ansible via a string representation that Ansible can turn back into a list.
ja: Python2 では、:meth:`dict.keys`、:meth:`dict.values`、および :meth:`dict.items` メソッドはリストを返します。Jinja2 は、Ansible がリストに戻ってきた文字列表現で Ansible に返します。

en: In Python3, those methods return a :ref:`dictionary view <python3:dict-views>` object. The string representation that Jinja2 returns for dictionary views cannot be parsed back into a list by Ansible.  It is, however, easy to make this portable by using the :func:`list <jinja2:list>` filter whenever using :meth:`dict.keys`, :meth:`dict.values`, or :meth:`dict.items`::
ja: Python3 では、これらのメソッドは :ref:`dictionary view <python3:dict-views>` オブジェクトを返します。Jinja2 がディクショナリービューに返す文字列表現は、Ansible ではリストに解析し直すことができません。しかし、:meth:`dict.keys`、:meth:`dict.values`、または :meth:`dict.items` を使用する際には必ず :func:`list <jinja2:list>` フィルターを使用することで、簡単に移植することができます。

en: Python2 dictionaries have :meth:`~dict.iterkeys`, :meth:`~dict.itervalues`, and :meth:`~dict.iteritems` methods.
ja: Python2 ディクショナリーには、:meth:`~dict.iterkeys` メソッド、:meth:`~dict.itervalues` メソッド、および :meth:`~dict.iteritems` メソッドがあります。

en: Python3 dictionaries do not have these methods. Use :meth:`dict.keys`, :meth:`dict.values`, and :meth:`dict.items` to make your playbooks and templates compatible with both Python2 and Python3::
ja: Python3 ディクショナリーにはこれらのメソッドがありません。:meth:`dict.keys`、:meth:`dict.values`、および :meth:`dict.items` を使用して、Playbook およびテンプレートを Python2 と Python3 の両方に対応させてください。

en: The :ref:`pb-py-compat-dict-views` entry for information on why the :func:`list filter <jinja2:list>` is necessary here.
ja: ここで :func:`list filter <jinja2:list>` が必要な理由は、:ref:`pb-py-compat-dict-views` エントリーを参照してください。

en: Re-using Ansible artifacts
ja: Ansible アーティファクトの再利用

en: You can write a simple playbook in one very large file, and most users learn the one-file approach first. However, breaking tasks up into different files is an excellent way to organize complex sets of tasks and reuse them. Smaller, more distributed artifacts let you re-use the same variables, tasks, and plays in multiple playbooks to address different use cases. You can use distributed artifacts across multiple parent playbooks or even multiple times within one playbook. For example, you might want to update your customer database as part of several different playbooks. If you put all the tasks related to updating your database in a tasks file, you can re-use them in many playbooks while only maintaining them in one place.
ja: 簡単な Playbook を非常に大きな 1 つのファイルに書くことができるため、ほとんどのユーザーはまず 1 つのファイルを使用した方法を学びます。しかし、タスクを異なるファイルに分割することは、複雑なタスクのセットを整理して再利用するための優れた方法です。小さく分散されたアーティファクトを使用して、同じ変数、タスク、プレイを複数の Playbook で再利用し、異なるユースケースに対応することができます。分散されたアーティファクトは、複数の親 Playbook にまたがって使用することも、1 つの Playbook 内で複数回使用することもできます。たとえば、複数の Playbook の一部として顧客データベースを更新する場合があります。データベースの更新に関連するすべてのタスクをタスクファイルにまとめておけば、それらを 1 カ所で管理するだけで、多くの Playbook で再利用することができます。

en: Creating re-usable files and roles
ja: 再利用可能なファイルおよびロールの作成

en: Ansible offers four distributed, re-usable artifacts: variables files, task files, playbooks, and roles.
ja: Ansible は、変数ファイル、タスクファイル、Playbook、およびロールの 4 つに分散した再利用可能なアーティファクトを提供します。

en: A variables file contains only variables.
ja: 変数ファイルには変数のみが含まれます。

en: A task file contains only tasks.
ja: タスクファイルにはタスクのみが含まれます。

en: A playbook contains at least one play, and may contain variables, tasks, and other content. You can re-use tightly focused playbooks, but you can only re-use them statically, not dynamically.
ja: Playbook には、少なくとも 1 つのプレイが含まれており、変数、タスク、その他のコンテンツを含むことができます。厳密に焦点を絞った Playbook は再利用できますが、動的にではなく静的にしか再利用できません。

en: A role contains a set of related tasks, variables, defaults, handlers, and even modules or other plugins in a defined file-tree. Unlike variables files, task files, or playbooks, roles can be easily uploaded and shared via Ansible Galaxy. See :ref:`playbooks_reuse_roles` for details about creating and using roles.
ja: ロールには、関連するタスク、変数、デフォルト、ハンドラー、さらにはモジュールや他のプラグインのセットが、定義されたファイルツリーに格納されています。変数ファイル、タスクファイル、Playbook とは異なり、ロールは Ansible Galaxy で簡単にアップロードして共有することができます。ロールの作成と使用の詳細については、「:ref:`playbooks_reuse_roles`」を参照してください。

en: Re-using playbooks
ja: Playbook の再利用

en: You can incorporate multiple playbooks into a main playbook. However, you can only use imports to re-use playbooks. For example:
ja: 複数の Playbook をメインの Playbook に組み込むことができますが、インポートのみを使用して Playbook を再使用できます。以下に例を示します。

en: Importing incorporates playbooks in other playbooks statically. Ansible runs the plays and tasks in each imported playbook in the order they are listed, just as if they had been defined directly in the main playbook.
ja: インポートでは、他の Playbook に静的に Playbook を組み込みます。Ansible は、インポートした各 Playbook 内のプレイやタスクを、メインの Playbook で直接定義した場合と同様に、リストに記載された順に実行します。

en: Re-using files and roles
ja: ファイルおよびロールの再利用

en: Ansible offers two ways to re-use files and roles in a playbook: dynamic and static.
ja: Ansible は、Playbook でファイルとロールを再利用する 2 つの方法 (動的および静的) を提供します。

en: For dynamic re-use, add an ``include_*`` task in the tasks section of a play:
ja: 動的再利用には、プレイの tasks セクションに ``include_*`` タスクを追加します。

en: For static re-use, add an ``import_*`` task in the tasks section of a play:
ja: 静的な再利用の場合は、プレイの tasks セクションに ``import_*`` タスクを追加します。

en: Task include and import statements can be used at arbitrary depth.
ja: タスクの include 文および import 文は任意の深さで使用できます。

en: You can still use the bare :ref:`roles <roles_keyword>` keyword at the play level to incorporate a role in a playbook statically. However, the bare :ref:`include <include_module>` keyword, once used for both task files and playbook-level includes, is now deprecated.
ja: プレイレベルで裸の :ref:`roles <roles_keyword>` キーワードを使用して、ロールを静的に Playbook に組み込むことは可能です。しかし、かつてタスクファイルと Playbook レベルのインクルードの両方に使用されていた裸の :ref:`include <include_module>` キーワードは、現在では非推奨となっています。

en: Includes: dynamic re-use
ja: インクルード: 動的再利用

en: Including roles, tasks, or variables adds them to a playbook dynamically. Ansible processes included files and roles as they come up in a playbook, so included tasks can be affected by the results of earlier tasks within the top-level playbook. Included roles and tasks are similar to handlers - they may or may not run, depending on the results of other tasks in the top-level playbook.
ja: ロール、タスク、または変数をインクルードすると、Playbook に動的に追加されます。Ansible は、Playbook に同梱されるインクルードファイルやロールを処理するため、インクルードタスクは、トップレベルの Playbook 内の以前のタスクの結果によって影響を受ける可能性があります。インクルードされるロールやタスクは、ハンドラーと同様、トップレベルの Playbook 内の他のタスクの結果に応じて、実行されたりされなかったりします。

en: The primary advantage of using ``include_*`` statements is looping. When a loop is used with an include, the included tasks or role will be executed once for each item in the loop.
ja: ``include_*`` 文を使用する主な利点はループです。インクルードでループが使用されると、インクルードされたタスクまたはロールがループの各項目に対して 1 回実行されます。

en: You can pass variables into includes. See :ref:`ansible_variable_precedence` for more details on variable inheritance and precedence.
ja: 変数をインクルードに渡すことができます。変数の継承と優先順位の詳細は、「:ref:`ansible_variable_precedence`」を参照してください。

en: Imports: static re-use
ja: インポート: 静的再利用

en: Importing roles, tasks, or playbooks adds them to a playbook statically. Ansible pre-processes imported files and roles before it runs any tasks in a playbook, so imported content is never affected by other tasks within the top-level playbook.
ja: ロール、タスク、または Playbook をインポートすると、それらが静的に Playbook に追加されます。Ansible は、インポートされたファイルやロールを Playbook 内のタスクを実行する前に前処理するため、インポートされたコンテンツがトップレベルの Playbook 内の他のタスクの影響を受けることはありません。

en: You can pass variables to imports. You must pass variables if you want to run an imported file more than once in a playbook. For example:
ja: インポートには変数を渡すことができます。インポートしたファイルを 1 つの Playbook で複数回実行する場合は、変数を渡す必要があります。以下に例を示します。

en: See :ref:`ansible_variable_precedence` for more details on variable inheritance and precedence.
ja: 変数の継承および優先順位に関する詳細は、「:ref:`ansible_variable_precedence`」を参照してください。

en: Comparing includes and imports: dynamic and static re-use
ja: インクルードとインポートの比較: 動的再利用および静的再利用

en: Each approach to re-using distributed Ansible artifacts has advantages and limitations. You may choose dynamic re-use for some playbooks and static re-use for others. Although you can use both dynamic and static re-use in a single playbook, it is best to select one approach per playbook. Mixing static and dynamic re-use can introduce difficult-to-diagnose bugs into your playbooks. This table summarizes the main differences so you can choose the best approach for each playbook you create.
ja: 分散した Ansible のアーティファクトを再利用する方法には、それぞれ利点と制限があります。一部の Playbook では動的再利用を行い、他の Playbook では静的再利用を行うことができます。1 つの Playbook で動的再利用と静的再利用の両方を使用することもできますが、Playbook ごとに 1 つのアプローチを選択するのが最善です。静的再利用と動的再利用を混在させると、診断が困難なバグが Playbook に発生する可能性があります。この表で主な違いをまとめています。作成する Playbook ごとに最適な方法を選択してください。

en: Type of re-use
ja: 再利用の種類

en: Dynamic
ja: 動的

en: Static
ja: 静的

en: When processed
ja: 処理時

en: At runtime, when encountered
ja: ランタイム時に (発生した場合)

en: Pre-processed during playbook parsing
ja: Playbook の解析中に事前処理

en: Task or play
ja: タスクまたはプレイ

en: All includes are tasks
ja: インクルードはすべてタスク

en: ``import_playbook`` cannot be a task
ja: ``import_playbook`` タスクにすることはできない

en: Task options
ja: タスクオプション

en: Apply only to include task itself
ja: タスク自体を含める場合にのみ適用

en: Apply to all child tasks in import
ja: インポート中のすべての子タスクに適用

en: Calling from loops
ja: ループからの呼び出し

en: Executed once for each loop item
ja: 各ループ項目に対して 1 回実行

en: Cannot be used in a loop
ja: ループでは使用できない

en: Using ``--list-tags``
ja: ``--list-tags`` の使用

en: Tags within includes not listed
ja: 掲載されていないインクルード内のタグ

en: All tags appear with ``--list-tags``
ja: すべてのタグが ``--list-tags`` で表示

en: Using ``--list-tasks``
ja: ``--list-tasks`` の使用

en: Tasks within includes not listed
ja: リストにないインクルード内のタスク

en: All tasks appear with ``--list-tasks``
ja: すべてのタスクが ``--list-tasks`` で表示

en: Notifying handlers
ja: ハンドラーの通知

en: Cannot trigger handlers within includes
ja: インクルード内でハンドラーをトリガーできない

en: Can trigger individual imported handlers
ja: インポートした個別のハンドラーをトリガーできる

en: Using ``--start-at-task``
ja: ``--start-at-task`` の使用

en: Cannot start at tasks within includes
ja: インクルード内のタスクで開始できない

en: Can start at imported tasks
ja: インポートされたタスクから始められる

en: Using inventory variables
ja: インベントリー変数の使用

en: Can ``include_*: {{ inventory_var }}``
ja: ``include_*: {{ inventory_var }}`` が使用できる

en: Cannot ``import_*: {{ inventory_var }}``
ja: ``import_*: {{ inventory_var }}`` が使用できない

en: With playbooks
ja: Playbook の使用

en: No ``include_playbook``
ja: ``include_playbook`` なし

en: Can import full playbooks
ja: 完全な Playbook をインポートできる

en: With variables files
ja: 変数ファイルの使用

en: Can include variables files
ja: 変数ファイルを含めることができる

en: Use ``vars_files:`` to import variables
ja: ``vars_files:`` を使用して変数をインポート

en: There are also big differences in resource consumption and performance, imports are quite lean and fast, while includes require a lot of management and accounting.
ja: また、リソースの消費やパフォーマンスに大きな違いがあり、インポートは非常に柔軟で高速ですが、インクルードには多くの管理と会計が必要になります。

en: Re-using tasks as handlers
ja: タスクをハンドラーとして再利用

en: You can also use includes and imports in the :ref:`handlers` section of a playbook. For instance, if you want to define how to restart Apache, you only have to do that once for all of your playbooks. You might make a ``restarts.yml`` file that looks like:
ja: Playbook の :ref:`handlers` セクションでインクルードおよびインポートを使用することもできます。たとえば、Apache の再起動方法を定義する場合は、すべての Playbook に対して一度だけ設定する必要があります。``restarts.yml`` ファイルを以下のように行うことができます。

en: You can trigger handlers from either an import or an include, but the procedure is different for each method of re-use. If you include the file, you must notify the include itself, which triggers all the tasks in ``restarts.yml``. If you import the file, you must notify the individual task(s) within ``restarts.yml``. You can mix direct tasks and handlers with included or imported tasks and handlers.
ja: ハンドラーはインポートとインクルードのどちらからでも起動できますが、その手順は再利用の方法ごとに異なります。ファイルをインクルードする場合は、インクルード自体を通知する必要があり、これにより ``restarts.yml`` のすべてのタスクが発生します。ファイルをインポートする場合は、``restarts.yml`` 内の個々のタスクを通知する必要があります。直接的なタスクやハンドラーと、インクルードまたはインポートされたタスクやハンドラーを混在させることができます。

en: Triggering included (dynamic) handlers
ja: インクルード (動的) ハンドラーのトリガー

en: Includes are executed at run-time, so the name of the include exists during play execution, but the included tasks do not exist until the include itself is triggered. To use the ``Restart apache`` task with dynamic re-use, refer to the name of the include itself. This approach triggers all tasks in the included file as handlers. For example, with the task file shown above:
ja: インクルードはランタイムに実行されるため、インクルードの名前はプレイの実行中に存在しますが、インクルードされたタスクはインクルード自体がトリガーされるまで存在しません。``Restart apache`` タスクを動的再利用で使用するには、インクルード自体の名前を参照します。この方法では、インクルードファイル内のすべてのタスクがハンドラーとしてトリガーされます。たとえば、上に示したタスクファイルでは、以下のようになります。

en: Triggering imported (static) handlers
ja: インポートされた (静的) ハンドラーのトリガー

en: Imports are processed before the play begins, so the name of the import no longer exists during play execution, but the names of the individual imported tasks do exist. To use the ``Restart apache`` task with static re-use, refer to the name of each task or tasks within the imported file. For example, with the task file shown above:
ja: インポートは再生開始前に処理されるため、インポートの名前は再生実行中には存在しませんが、インポートされた各タスクの名前は存在します。``Restart apache`` タスクを静的に再利用して使用するには、インポートされたファイル内の各タスクの名前を参照する必要があります。たとえば、上述のタスクファイルであれば、以下のようになります。

en: Documentation of the ``include*`` and ``import*`` modules discussed here.
ja: ここで説明する ``include*`` モジュールおよび ``import*`` モジュールに関するドキュメント

en: Review the basic Playbook language features
ja: 基本的な Playbook 言語機能の確認

en: All about variables in playbooks
ja: Playbook の変数の詳細のすべて

en: Conditionals in playbooks
ja: Playbook の条件

en: Loops in playbooks
ja: Playbook のループ

en: How to share roles on galaxy, role management
ja: Galaxy (ロール管理) におけるロールの共有方法

en: `GitHub Ansible examples <https://github.com/ansible/ansible-examples>`_
ja: `GitHub Ansible の例 <https://github.com/ansible/ansible-examples>`_

en: Complete playbook files from the GitHub project source
ja: Github プロジェクトソースの完全な Playbook ファイル

en: Including and importing
ja: インクルードおよびインポート

en: The content on this page has been moved to :ref:`playbooks_reuse`.
ja: このページのコンテンツは :ref:`playbooks_reuse` に移動しました。

en: Roles
ja: ロール

en: Roles let you automatically load related vars, files, tasks, handlers, and other Ansible artifacts based on a known file structure. After you group your content in roles, you can easily reuse them and share them with other users.
ja: ロールを使用すると、既知のファイル構造に基づいて、関連の変数、ファイル、タスク、ハンドラー、およびその他の Ansible アーティファクトを自動的に読み込むことができます。ロール内のコンテンツをグループ化した後、簡単に再利用でき、他のユーザーと共有できます。

en: Role directory structure
ja: ロールのディレクトリー構造

en: An Ansible role has a defined directory structure with eight main standard directories. You must include at least one of these directories in each role. You can omit any directories the role does not use. For example:
ja: Ansible ロールには、8 つの主要な標準ディレクトリーを持つ定義されたディレクトリー構造があります。各ロールには、ディレクトリーを少なくとも 1 つ含める必要があります。ロールが使用されないディレクトリーは除外できます。以下に例を示します。

en: By default Ansible will look in each directory within a role for a ``main.yml`` file for relevant content (also ``main.yaml`` and ``main``):
ja: デフォルトでは、Ansible はロール内の各ディレクトリーで、関連するコンテンツ (``main.yaml`` および ``main``) について ``main.yml`` ファイルを検索します。

en: ``tasks/main.yml`` - the main list of tasks that the role executes.
ja: ``tasks/main.yml`` - ロールが実行するタスクの主なリスト。

en: ``handlers/main.yml`` - handlers, which may be used within or outside this role.
ja: ``handlers/main.yml`` - このロール内外で使用できるハンドラー。

en: ``library/my_module.py`` - modules, which may be used within this role (see :ref:`embedding_modules_and_plugins_in_roles` for more information).
ja: ``library/my_module.py`` - このロール内で使用できるモジュール (詳細は「:ref:`embedding_modules_and_plugins_in_roles`」を参照)。

en: ``defaults/main.yml`` - default variables for the role (see :ref:`playbooks_variables` for more information). These variables have the lowest priority of any variables available, and can be easily overridden by any other variable, including inventory variables.
ja: ``defaults/main.yml`` - ロールのデフォルト変数 (詳細は「:ref:`playbooks_variables`」を参照)。これらの変数には、利用可能な変数の中で一番低い優先順位があり、インベントリー変数など、他の変数で簡単に上書きできます。

en: ``vars/main.yml`` - other variables for the role (see :ref:`playbooks_variables` for more information).
ja: ``vars/main.yml`` - ロールの他の変数 (詳細は :ref:`playbooks_variables` を参照)。

en: ``files/main.yml`` - files that the role deploys.
ja: ``files/main.yml`` - ロールがデプロイするファイル。

en: ``templates/main.yml`` - templates that the role deploys.
ja: ``templates/main.yml`` - ロールがデプロイするテンプレート。

en: ``meta/main.yml`` - metadata for the role, including role dependencies.
ja: ``meta/main.yml`` - ロールの依存関係を含むロールのメタデータ。

en: You can add other YAML files in some directories. For example, you can place platform-specific tasks in separate files and refer to them in the ``tasks/main.yml`` file:
ja: 他の YAML ファイルを一部のディレクトリーに追加できます。たとえば、プラットフォーム固有のタスクを別々のファイルに配置し、それらを ``tasks/main.yml`` ファイルで参照できます。

en: Roles may also include modules and other plugin types in a directory called ``library``. For more information, please refer to :ref:`embedding_modules_and_plugins_in_roles` below.
ja: ロールには、``library`` と呼ばれるディレクトリーにモジュールおよびその他のプラグインタイプが含まれる場合があります。詳細は、以下の「:ref:`embedding_modules_and_plugins_in_roles`」を参照してください。

en: Storing and finding roles
ja: ロールの保存および検索

en: By default, Ansible looks for roles in two locations:
ja: デフォルトでは、Ansible は 2 つの場所でロールを検索します。

en: in a directory called ``roles/``, relative to the playbook file
ja: ``roles/`` という名前のディレクトリー (Playbook ファイルへの相対パス) で

en: in ``/usr/local/etc/ansible/roles``
ja: ``/usr/local/etc/ansible/roles`` で

en: If you store your roles in a different location, set the :ref:`roles_path <DEFAULT_ROLES_PATH>` configuration option so Ansible can find your roles. Checking shared roles into a single location makes them easier to use in multiple playbooks. See :ref:`intro_configuration` for details about managing settings in ansible.cfg.
ja: ロールを別の場所に保存する場合は、Ansible がロールを見つけることができるように、:ref:`roles_path <DEFAULT_ROLES_PATH>` 設定オプションを設定します。共有ロールを 1 つの場所にチェックインすることで、複数の Playbook で簡単に使用できます。ansible.cfg の設定に関する詳細は、「:ref:`intro_configuration`」を参照してください。

en: Alternatively, you can call a role with a fully qualified path:
ja: または、完全修飾パスでロールを呼び出すことができます。

en: Using roles
ja: ロールの使用

en: You can use roles in three ways:
ja: 以下の 3 つの方法でロールを使用できます。

en: at the play level with the ``roles`` option: This is the classic way of using roles in a play.
ja: ``roles`` オプションを使用してプレイレベルで: プレイでロールを使用する従来の方式です。

en: at the tasks level with ``include_role``: You can reuse roles dynamically anywhere in the ``tasks`` section of a play using ``include_role``.
ja: ``include_role`` を使用してタスクレベルで: ``include_role`` を使用してプレイの ``tasks`` セクションのどこからでもロールを動的に再利用できます。

en: at the tasks level with ``import_role``: You can reuse roles statically anywhere in the ``tasks`` section of a play using ``import_role``.
ja: ``import_role`` を使用してタスクレベルで: ``import_role`` を使用してプレイの ``tasks`` セクションのどこからでもロールを静的に再利用できます。

en: Using roles at the play level
ja: プレイレベルでのロールの使用

en: The classic (original) way to use roles is with the ``roles`` option for a given play:
ja: ロールを使用する従来の (元の) 方法は、特定のプレイの ``roles`` オプションを使用して行います。

en: When you use the ``roles`` option at the play level, for each role 'x':
ja: プレイレベルで ``roles`` オプションを使用する場合は、各ロール「x」に対して以下のように設定します。

en: If roles/x/tasks/main.yml exists, Ansible adds the tasks in that file to the play.
ja: roles/x/tasks/main.yml が存在する場合、Ansible はそのファイルのタスクをプレイに追加します。

en: If roles/x/handlers/main.yml exists, Ansible adds the handlers in that file to the play.
ja: roles/x/handlers/main.yml が存在する場合、Ansible はそのファイルのハンドラーをプレイに追加します。

en: If roles/x/vars/main.yml exists, Ansible adds the variables in that file to the play.
ja: roles/x/vars/main.yml が存在する場合、Ansible はそのファイルの変数をプレイに追加します。

en: If roles/x/defaults/main.yml exists, Ansible adds the variables in that file to the play.
ja: roles/x/defaults/main.yml が存在する場合、Ansible はそのファイルの変数をプレイに追加します。

en: If roles/x/meta/main.yml exists, Ansible adds any role dependencies in that file to the list of roles.
ja: roles/x/meta/main.yml が存在する場合、Ansible はそのファイル内のすべてのロールの依存関係をロールのリストに追加します。

en: Any copy, script, template or include tasks (in the role) can reference files in roles/x/{files,templates,tasks}/ (dir depends on task) without having to path them relatively or absolutely.
ja: コピー、スクリプト、テンプレート、またはインクルードタスク (ロール内) は、相対パスや絶対パスを必要とせずに roles/x/{files,templates,tasks}/ (ディレクトリーはタスクに依存します) のファイルを参照できます。

en: When you use the ``roles`` option at the play level, Ansible treats the roles as static imports and processes them during playbook parsing. Ansible executes your playbook in this order:
ja: プレイレベルで ``roles`` オプションを使用すると、Ansible はロールを静的インポートとして処理し、Playbook の解析時に処理します。Ansible は以下の順序で Playbook を実行します。

en: Any ``pre_tasks`` defined in the play.
ja: プレイに定義されているすべての ``pre_tasks``。

en: Any handlers triggered by pre_tasks.
ja: ハンドラーは、pre_tasks により誘発されます。

en: Each role listed in ``roles:``, in the order listed. Any role dependencies defined in the role's ``meta/main.yml`` run first, subject to tag filtering and conditionals. See :ref:`role_dependencies` for more details.
ja: ``roles:`` に一覧表示される順序で、各ロールがリストされます。ロールの ``meta/main.yml`` で定義されたロール依存関係は、タグのフィルタリングおよび条件に基づいて最初に実行されます。詳細は、「:ref:`role_dependencies`」を参照してください。

en: Any ``tasks`` defined in the play.
ja: プレイに定義されているすべての ``tasks``。

en: Any handlers triggered by the roles or tasks.
ja: ロールやタスクによってトリガーされるすべてのハンドラー。

en: Any ``post_tasks`` defined in the play.
ja: プレイに定義されているすべての ``post_tasks``。

en: Any handlers triggered by post_tasks.
ja: ハンドラーは、post_tasks により誘発されます。

en: If using tags with tasks in a role, be sure to also tag your pre_tasks, post_tasks, and role dependencies and pass those along as well, especially if the pre/post tasks and role dependencies are used for monitoring outage window control or load balancing. See :ref:`tags` for details on adding and using tags.
ja: ロール内のタスクにタグを使用する場合は、pre_tasks、post_tasks、およびロールの依存関係にもタグを付けて、それらも渡すようにしてください。特に、事前または事後のタスクおよびロールの依存関係が、停止時のウィンドウ制御や負荷分散の監視に使用されている場合は、そのようにしてください。タグの追加と使用の詳細は、「:ref:`tags`」を参照してください。

en: You can pass other keywords to the ``roles`` option:
ja: 他のキーワードを ``roles`` オプションに渡すことができます。

en: When you add a tag to the ``role`` option, Ansible applies the tag to ALL tasks within the role.
ja: タグを ``role`` オプションに追加すると、Ansible はタグをロール内のすべてのタスクに適用します。

en: When using ``vars:`` within the ``roles:`` section of a playbook, the variables are added to the play variables, making them available to all tasks within the play before and after the role. This behavior can be changed by :ref:`DEFAULT_PRIVATE_ROLE_VARS`.
ja: Playbook の ``roles:`` セクションで ``vars:`` を使用すると、変数がプレイ変数に追加され、ロールの前後にプレイ内のすべてのタスクで利用できるようになります。この動作は :ref:`DEFAULT_PRIVATE_ROLE_VARS` で変更できます。

en: Including roles: dynamic reuse
ja: ロールの追加: 動的な再利用

en: You can reuse roles dynamically anywhere in the ``tasks`` section of a play using ``include_role``. While roles added in a ``roles`` section run before any other tasks in a playbook, included roles run in the order they are defined. If there are other tasks before an ``include_role`` task, the other tasks will run first.
ja: ``include_role`` を使用すると、プレイの ``tasks`` セクション内の任意の場所でロールを動的に再利用することができます。``roles`` セクションで追加されたロールは Playbook 内の他のタスクよりも先に実行されますが、含まれるロールは定義された順に実行されます。``include_role`` のタスクの前に他のタスクがある場合は、他のタスクが先に実行します。

en: To include a role:
ja: ロールを指定するには、以下を実行します。

en: You can pass other keywords, including variables and tags, when including roles:
ja: ロールを含める際には、変数やタグなど、他のキーワードを渡すことができます。

en: When you add a :ref:`tag <tags>` to an ``include_role`` task, Ansible applies the tag `only` to the include itself. This means you can pass ``--tags`` to run only selected tasks from the role, if those tasks themselves have the same tag as the include statement. See :ref:`selective_reuse` for details.
ja: ``include_role`` タスクに :ref:`tag <tags>` を追加すると、Ansible はインクルード自体に `only` というタグを適用します。つまり、``--tags`` を渡して、ロールから選択されたタスクのみを実行することができます。ただし、それらのタスク自体が include 文と同じタグを持っている場合に限ります。詳細は、「:ref:`selective_reuse`」を参照してください。

en: You can conditionally include a role:
ja: ロールを条件付きで含めることができます。

en: Importing roles: static reuse
ja: ロールのインポート: 静的再利用

en: You can reuse roles statically anywhere in the ``tasks`` section of a play using ``import_role``. The behavior is the same as using the ``roles`` keyword. For example:
ja: ``import_role`` を使用してプレイの ``tasks`` セクションの任意の場所に、ロールを静的に再利用できます。動作は、``roles`` キーワードの使用と同じです。以下に例を示します。

en: You can pass other keywords, including variables and tags, when importing roles:
ja: ロールをインポートする際には、変数やタグなど、他のキーワードを渡すことができます。

en: When you add a tag to an ``import_role`` statement, Ansible applies the tag to `all` tasks within the role. See :ref:`tag_inheritance` for details.
ja: タグを ``import_role`` 文に追加すると、Ansible はタグをロール内の `all` タスクに適用します。詳細は、「:ref:`tag_inheritance`」を参照してください。

en: Role argument validation
ja: ロール引数を検証する

en: Beginning with version 2.11, you may choose to enable role argument validation based on an argument specification. This specification is defined in the ``meta/argument_specs.yml`` file (or with the ``.yaml`` file extension). When this argument specification is defined, a new task is inserted at the beginning of role execution that will validate the parameters supplied for the role against the specification. If the parameters fail validation, the role will fail execution.
ja: バージョン 2.11 以降では、引数の仕様に基づいてロールの引数検証を有効にすることができます。この仕様は、``meta/argument_specs.yml`` ファイル (または ``.yaml`` ファイル拡張子) で定義されます。この引数仕様が定義されると、ロール実行の最初に新しいタスクが挿入され、仕様に対して、ロールに指定したパラメーターを検証します。パラメーターの検証に失敗した場合は、ロールの実行が失敗します。

en: Ansible also supports role specifications defined in the role ``meta/main.yml`` file, as well. However, any role that defines the specs within this file will not work on versions below 2.11. For this reason, we recommend using the ``meta/argument_specs.yml`` file to maintain backward compatibility.
ja: Ansible は、ロールの ``meta/main.yml`` ファイルで定義されるロールの仕様もサポートしますが、このファイル内の仕様を定義するロールは 2.11 未満のバージョンでは動作しません。そのため、``meta/argument_specs.yml`` ファイルを使用して後方互換性を維持することが推奨されます。

en: When role argument validation is used on a role that has defined :ref:`dependencies <role_dependencies>`, then validation on those dependencies will run before the dependent role, even if argument validation fails for the dependent role.
ja: :ref:`dependencies <role_dependencies>` を定義しているロールにロールの引数検証が使用されている場合は、依存するロールの引数検証が失敗しても、それらの依存関係の検証は依存するロールの前に実行します。

en: Specification format
ja: 仕様の形式

en: The role argument specification must be defined in a top-level ``argument_specs`` block within the role ``meta/argument_specs.yml`` file. All fields are lower-case.
ja: ロール引数の指定は、ロール ``meta/argument_specs.yml`` ファイルの上位の ``argument_specs`` ブロックで定義する必要があります。すべてのフィールドは小文字になります。

en: The name of the role entry point.
ja: ロールエントリーポイントの名前。

en: This should be ``main`` in the case of an unspecified entry point.
ja: これは、エントリーポイントが未指定の場合は ``main`` である必要があります。

en: This will be the base name of the tasks file to execute, with no ``.yml`` or ``.yaml`` file extension.
ja: これは、ファイル拡張子 ``.yml`` または ``.yaml`` のない、実行するタスクファイルのベース名です。

en: A short, one-line description of the entry point.
ja: エントリーポイントの 1 行の短い説明。

en: The ``short_description`` is displayed by ``ansible-doc -t role -l``.
ja: ``short_description`` は、``ansible-doc -t role -l`` に表示されます。

en: A longer description that may contain multiple lines.
ja: 複数の行が含まれる可能性のある長い説明。

en: Name of the entry point authors.
ja: エントリーポイント作成者の名前。

en: Use a multi-line list if there is more than one author.
ja: 作成者が複数になる場合は、複数行のリストを使用します。

en: Options are often called "parameters" or "arguments". This section defines those options.
ja: オプションは、しばしば「パラメーター」や「引数」と呼ばれます。このセクションでは、それらのオプションを定義します。

en: For each role option (argument), you may include:
ja: 各ロールオプション (引数) に以下を含めることができます。

en: The name of the option/argument.
ja: オプション/引数の名前。

en: Detailed explanation of what this option does. It should be written in full sentences.
ja: * このオプションの機能の詳細な説明。これは、完全な文章で記述する必要があります。

en: The data type of the option. Default is ``str``.
ja: オプションのデータタイプ。デフォルトは ``str`` です。

en: If an option is of type ``list``, ``elements`` should be specified.
ja: オプションが ``list`` タイプの場合は、``elements`` を指定する必要があります。

en: required
ja: 必須

en: Only needed if ``true``.
ja: ``true`` の場合にのみ必要です。

en: If missing, the option is not required.
ja: 見つからない場合、そのオプションは必要ありません。

en: If ``required`` is false/missing, ``default`` may be specified (assumed 'null' if missing).
ja: ``required`` が false もしくは指定されていない場合は、``default`` を指定できます (見つからない場合は「null」と見なされます)。

en: Ensure that the default value in the docs matches the default value in the code. The actual default for the role variable will always come from ``defaults/main.yml``.
ja: ドキュメントのデフォルト値が、コードのデフォルト値と一致していることを確認します。ロール変数の実際のデフォルトは常に ``defaults/main.yml`` から取得されます。

en: The default field must not be listed as part of the description, unless it requires additional information or conditions.
ja: 追加の情報や条件が必要な場合を除き、デフォルトのフィールドは、説明の一部として記載しないでください。

en: If the option is a boolean value, you can use any of the boolean values recognized by Ansible: (such as true/false or yes/no).  Choose the one that reads better in the context of the option.
ja: オプションがブール値の場合は、Ansible が認識する任意のブール値 (true/false、yes/no など) を使用できます。オプションのコンテキストで読み取りが適切であればこれを選択します。

en: List of option values.
ja: * オプション値のリスト。

en: Should be absent if empty.
ja: 空欄の場合は指定なしになります。

en: Specifies the data type for list elements when type is ``list``.
ja: タイプが ``list`` の場合に、リスト要素のデータ型を指定します。

en: If this option takes a dict or list of dicts, you can define the structure here.
ja: このオプションがディクショナリーまたはディクショナリーの一覧を取る場合は、ここで構造を定義できます。

en: Sample specification
ja: サンプル仕様

en: Running a role multiple times in one playbook
ja: 1 つの Playbook でロールを複数回実行する

en: Ansible only executes each role once, even if you define it multiple times, unless the parameters defined on the role are different for each definition. For example, Ansible only runs the role ``foo`` once in a play like this:
ja: Ansible は、ロールに定義されているパラメーターが定義ごとに異なる場合を除き、各ロールを複数回定義しても 1 回しか実行しません。たとえば、Ansible は次のようなプレイで ``foo`` というロールを 1 回だけ実行します。

en: You have two options to force Ansible to run a role more than once.
ja: Ansible が複数のロールを強制的に実行するオプションは 2 つあります。

en: Passing different parameters
ja: 異なるパラメーターを渡す

en: If you pass different parameters in each role definition, Ansible runs the role more than once. Providing different variable values is not the same as passing different role parameters. You must use the ``roles`` keyword for this behavior, since ``import_role`` and ``include_role`` do not accept role parameters.
ja: 各ロール定義で異なるパラメーターを渡すと、Ansible はそのロールを複数回実行します。異なる変数値を提供することは、異なるロールパラメーターを渡すこととは異なります。``import_role`` および ``include_role`` はロールパラメーターを受け入れないため、この動作には ``roles`` キーワードを使用する必要があります。

en: This playbook runs the ``foo`` role twice:
ja: この Playbook では、``foo`` ロールが 2 回実行されます。

en: This syntax also runs the ``foo`` role twice;
ja: この構文は、``foo`` ロールを 2 回実行します。

en: In these examples, Ansible runs ``foo`` twice because each role definition has different parameters.
ja: これらの例では、各ロール定義のパラメーターが異なるため、Ansible は ``foo`` を 2 回実行します。

en: Using ``allow_duplicates: true``
ja: ``allow_duplicates: true`` の使用

en: Add ``allow_duplicates: true`` to the ``meta/main.yml`` file for the role:
ja: ロールの ``meta/main.yml`` ファイルに ``allow_duplicates: true`` を追加します。

en: In this example, Ansible runs ``foo`` twice because we have explicitly enabled it to do so.
ja: この例では、Ansible が ``foo`` を2回実行していますが、これは明示的に実行できるようにしたためです。

en: Using role dependencies
ja: ロール依存関係の使用

en: Role dependencies let you automatically pull in other roles when using a role. Ansible does not execute role dependencies when you include or import a role. You must use the ``roles`` keyword if you want Ansible to execute role dependencies.
ja: ロールの依存関係により、あるロールを使用する際に他のロールを自動的に取り込むことができます。Ansible は、ロールをインクルードまたはインポートする際にロールの依存関係を実行しません。Ansible でロールの依存関係を実行したい場合は、``roles`` キーワードを使用する必要があります。

en: Role dependencies are prerequisites, not true dependencies. The roles do not have a parent/child relationship. Ansible loads all listed roles, runs the roles listed under ``dependencies`` first, then runs the role that lists them. The play object is the parent of all roles, including roles called by a ``dependencies`` list.
ja: ロールの依存関係は前提条件であり、真の依存関係ではありません。また、ロールは親子関係を持ちません。Ansible はリストアップされたすべてのロールを読み込み、``dependencies`` にリストアップされたロールを最初に実行し、次にそれらをリストアップしたロールを実行します。play オブジェクトは、``dependencies`` のリストで呼び出されるロールを含め、すべてのロールの親です。

en: Role dependencies are stored in the ``meta/main.yml`` file within the role directory. This file should contain a list of roles and parameters to insert before the specified role. For example:
ja: ロールの依存関係は、ロールディレクトリー内の ``meta/main.yml`` ファイルに保存されます。このファイルには、指定されたロールの前に挿入するロールとパラメーターの一覧を含める必要があります。以下に例を示します。

en: Ansible always executes roles listed in ``dependencies`` before the role that lists them. Ansible executes this pattern recursively when you use the ``roles`` keyword. For example, if you list role ``foo`` under ``roles:``, role ``foo`` lists role ``bar`` under ``dependencies`` in its meta/main.yml file, and role ``bar`` lists role ``baz`` under ``dependencies`` in its meta/main.yml, Ansible executes ``baz``, then ``bar``, then ``foo``.
ja: Ansible は、``dependencies`` に記載されているロールを、それを記載しているロールの前に常に実行します。``roles`` キーワードを使用すると、Ansible はこのパターンを再帰的に実行します。たとえば、ロール ``foo`` を ``roles:`` の下にリストし、ロール ``foo`` が meta/main.yml ファイルの ``dependencies`` の下にロール ``bar`` をリストし、ロール ``bar`` が meta/main.yml の ``dependencies`` の下にロール ``baz`` をリストしている場合、Ansibleは ``baz``、``bar``、``foo`` の順に実行します。

en: Running role dependencies multiple times in one playbook
ja: 1 つの Playbook でロールの依存関係を複数回実行する

en: Ansible treats duplicate role dependencies like duplicate roles listed under ``roles:``: Ansible only executes role dependencies once, even if defined multiple times, unless the parameters, tags, or when clause defined on the role are different for each definition. If two roles in a playbook both list a third role as a dependency, Ansible only runs that role dependency once, unless you pass different parameters, tags, when clause, or use ``allow_duplicates: true`` in the role you want to run multiple times. See :ref:`Galaxy role dependencies <galaxy_dependencies>` for more details.
ja: Ansible は、``roles:`` に記載されている重複したロールのように、重複したロールの依存関係を扱います。Ansible は、ロールに定義されたパラメーター、タグ、または when 句が定義ごとに異なる場合を除き、複数回定義されていてもロールの依存関係を 1 回のみ実行します。Playbook 内の 2 つのロールが両方とも依存関係として 3 番目のロールをリストしている場合、Ansible は、複数回実行するロールで異なるパラメーター、タグ、when 句を渡すか、``allow_duplicates: true`` を使用しない限り、そのロールの依存関係を 1 回のみ実行します。詳細は、「:ref:`Galaxy ロール依存関係 <galaxy_dependencies>`」を参照してください。

en: Role deduplication does not consult the invocation signature of parent roles. Additionally, when using ``vars:`` instead of role params, there is a side effect of changing variable scoping. Using ``vars:`` results in those variables being scoped at the play level. In the below example, using ``vars:`` would cause ``n`` to be defined as ``4`` through the entire play, including roles called before it.
ja: ロールの重複排除は、親ロールの呼び出し署名を参照しません。さらに、ロールパラメーターの代わりに ``vars:`` を使用する場合は、変数のスコープを変更するという副作用があります。``vars:`` を使用すると、それらの変数がプレイレベルで対象となります。以下の例では、``vars:`` を使用すると、それ以前に呼び出されたロールを含め、プレー全体を通して ``n`` が ``4`` として定義されることになります。

en: In addition to the above, users should be aware that role de-duplication occurs before variable evaluation. This means that :term:`Lazy Evaluation` may make seemingly different role invocations equivalently the same, preventing the role from running more than once.
ja: 上記に加えて、ユーザーは変数評価の前にロールの重複排除が行われることに注意する必要があります。つまり、:term:`Lazy Evaluation` は、一見異なるロールの呼び出しを等価にして、ロールが複数回実行されるのを防ぐことができます。

en: For example, a role named ``car`` depends on a role named ``wheel`` as follows:
ja: たとえば、``car`` という名前のロールは、以下のように ``wheel`` という名前のロールに依存します。

en: And the ``wheel`` role depends on two roles: ``tire`` and ``brake``. The ``meta/main.yml`` for wheel would then contain the following:
ja: そして、``wheel`` のロールは、``tire`` と ``brake`` の 2 つのロールに依存します。このため、wheel 用の ``meta/main.yml`` は以下のようになります。

en: And the ``meta/main.yml`` for ``tire`` and ``brake`` would contain the following:
ja: そして、「``tire``」および「``brake``」の「``meta/main.yml``」には、次のような内容が含まれています。

en: The resulting order of execution would be as follows:
ja: その結果作成される実行順序は以下のようになります。

en: To use ``allow_duplicates: true`` with role dependencies, you must specify it for the role listed under ``dependencies``, not for the role that lists it. In the example above, ``allow_duplicates: true`` appears in the ``meta/main.yml`` of the ``tire`` and ``brake`` roles. The ``wheel`` role does not require ``allow_duplicates: true``, because each instance defined by ``car`` uses different parameter values.
ja: ``allow_duplicates: true`` をロール依存で使用するには、それをリストしているロールではなく、``dependencies`` の下にリストされているロールに対して指定する必要があります。上記の例では、``allow_duplicates: true`` は、``tire`` ロールおよび ``brake`` ロールの ``meta/main.yml`` に表示されます。``wheel`` ロールは、``car`` で定義された各インスタンスが異なるパラメーター値を使用するため、``allow_duplicates: true`` を必要としません。

en: See :ref:`playbooks_variables` for details on how Ansible chooses among variable values defined in different places (variable inheritance and scope).
ja: Ansible が異なる場所 (変数継承およびスコープ) で定義される変数の値間で Ansible が選択する方法の詳細については、「:ref:`playbooks_variables`」を参照してください。

en: Embedding modules and plugins in roles
ja: ロールでのモジュールおよびプラグインの埋め込み

en: If you write a custom module (see :ref:`developing_modules`) or a plugin (see :ref:`developing_plugins`), you might wish to distribute it as part of a role. For example, if you write a module that helps configure your company's internal software, and you want other people in your organization to use this module, but you do not want to tell everyone how to configure their Ansible library path, you can include the module in your internal_config role.
ja: カスタムモジュール (:ref:`developing_modules` 参照) やプラグイン (:ref:`developing_plugins` 参照) を作成した場合は、ロールの一部として配布したい場合があります。たとえば、社内のソフトウェアを設定するためのモジュールを作成し、組織内の他の人にもこのモジュールを使用してほしいにも関わらず、Ansible のライブラリーパスを設定する方法を全員に開示したくない場合は、internal_config ロールにモジュールを含めることができます。

en: To add a module or a plugin to a role: Alongside the 'tasks' and 'handlers' structure of a role, add a directory named 'library' and then include the module directly inside the 'library' directory.
ja: モジュールやプラグインをロールに追加するには、ロールの「tasks」および「handlers」構造の横に、「library」という名前のディレクトリーを追加し、その「library」ディレクトリー内にモジュールを直接インクルードします。

en: Assuming you had this:
ja: 以下があるとします。

en: The module will be usable in the role itself, as well as any roles that are called *after* this role, as follows:
ja: モジュールは、次のように、ロール自体、およびこのロールの *後に* 呼び出されるすべてのロールで使用できます。

en: If necessary, you can also embed a module in a role to modify a module in Ansible's core distribution. For example, you can use the development version of a particular module before it is released in production releases by copying the module and embedding the copy in a role. Use this approach with caution, as API signatures may change in core components, and this workaround is not guaranteed to work.
ja: 必要に応じて、ロールにモジュールを埋め込み、Ansible のコアディストリビューションのモジュールを変更することもできます。たとえば、モジュールをコピーし、そのコピーをロールに埋め込むことで、特定のモジュールの開発バージョンを実稼働リリースの前に使用することができます。コアコンポーネントでは API シグネチャーが変更する可能性があり、この回避策は動作が保証されていないため、この方法は慎重に使用してください。

en: The same mechanism can be used to embed and distribute plugins in a role, using the same schema. For example, for a filter plugin:
ja: 同じスキーマを使用して、ロールにプラグインを埋め込んだり配布したりすることもできます。たとえば、フィルタープラグインの場合は、以下のようになります。

en: These filters can then be used in a Jinja template in any role called after 'my_custom_filter'.
ja: これらのフィルターは、Jinja のテンプレートで、「my_custom_filter」の後に呼ばれる任意のロールで使用することができます。

en: Sharing roles: Ansible Galaxy
ja: ロールの共有: Ansible Galaxy

en: `Ansible Galaxy <https://galaxy.ansible.com>`_ is a free site for finding, downloading, rating, and reviewing all kinds of community-developed Ansible roles and can be a great way to get a jumpstart on your automation projects.
ja: `Ansible Galaxy <https://galaxy.ansible.com>`_ は、コミュニティーで開発されたあらゆる種類の Ansible ロールを検索、ダウンロード、評価、およびレビューする無料サイトで、ここで自動化プロジェクトをすぐに開始するための優れた方法です。

en: The client ``ansible-galaxy`` is included in Ansible. The Galaxy client allows you to download roles from Ansible Galaxy, and also provides an excellent default framework for creating your own roles.
ja: クライアント ``ansible-galaxy`` は、Ansible に含まれています。Galaxy クライアントを使用すると、Ansible Galaxy からロールをダウンロードでき、独自のロールを作成する優れたデフォルトのフレームワークも提供します。

en: Read the `Ansible Galaxy documentation <https://galaxy.ansible.com/docs/>`_ page for more information
ja: 詳細は、`Ansible Galaxy ドキュメント <https://galaxy.ansible.com/docs/>`_ ページを参照してください。

en: How to create new roles, share roles on Galaxy, role management
ja: 新規ロールの作成、Galaxy でのロールの共有、およびロールの管理の方法

en: Variables in playbooks
ja: Playbook の変数

en: Using tags to select or skip roles/tasks in long playbooks
ja: タグを使用した長い Playbook でロール/タスクの選択またはスキップ

en: Extending Ansible by writing your own modules
ja: 独自のモジュールを作成して Ansible を拡張

en: Playbook Roles and Include Statements
ja: Playbook ロールおよび Include 文

en: The documentation regarding roles and includes for playbooks have moved. Their new location is here: :ref:`playbooks_reuse`. Please update any links you may have made directly to this page.
ja: Playbook のロールおよびインクルードに関するドキュメントが移動しました。新しい場所は「:ref:`playbooks_reuse`」です。このページに直接作成したリンクを更新してください。

en: Creating reusable Playbooks.
ja: 再利用可能な Playbook の作成

en: Advanced playbooks features
ja: Playbook の高度な機能

en: This page is obsolete. Refer to the :ref:`main User Guide index page <user_guide_index>` for links to all playbook-related topics. Please update any links you may have made directly to this page.
ja: このページは使用されなくなりました。Playbook に関連するすべてのトピックへのリンクは、:ref:`メインのユーザーガイドのインデックスページ <user_guide_index>` を参照してください。このページに直接リンクを張っている場合は更新してください。

en: Executing playbooks for troubleshooting
ja: トラブルシューティングのための Playbook の実行

en: When you are testing new plays or debugging playbooks, you may need to run the same play multiple times. To make this more efficient, Ansible offers two alternative ways to execute a playbook: start-at-task and step mode.
ja: 新しいプレイをテストしたり、Playbook をデバッグしたりする際に、同じプレイを複数回実行しないといけない場合があります。これを効率的に行うために、Ansible では Playbook の実行方法として、start-at-task モードと step モードの 2 種類を用意しています。

en: To start executing your playbook at a particular task (usually the task that failed on the previous run), use the ``--start-at-task`` option::
ja: 特定のタスク (通常は直前の実行で失敗したタスク) で Playbook の実行を開始するには、``--start-at-task`` オプションを使用します。

en: In this example, Ansible starts executing your playbook at a task named "install packages". This feature does not work with tasks inside dynamically re-used roles or tasks (``include_*``), see :ref:`dynamic_vs_static`.
ja: この例では、Ansible は「install packages」という名前のタスクで Playbook の実行を開始します。この機能は、動的に再利用されるロールやタスク内のタスク (``include_*``) では動作しません。「:ref:`dynamic_vs_static`」を参照してください。

en: Step mode
ja: step モード

en: To execute a playbook interactively, use ``--step``::
ja: Playbook を対話的に実行するには、``--step`` を使用します。

en: With this option, Ansible stops on each task, and asks if it should execute that task. For example, if you have a task called "configure ssh", the playbook run will stop and ask::
ja: このオプションを使用すると、Ansible は各タスクで停止し、そのタスクを実行すべきかどうかを尋ねます。たとえば、「configure ssh」という名前のタスクがあった場合、Playbook の実行は停止し、次のように尋ねてきます。

en: Answer "y" to execute the task, answer "n" to skip the task, and answer "c" to exit step mode, executing all remaining tasks without asking.
ja: 「y」と答えてタスクを実行し、「n」と答えてタスクをスキップし、「c」と応えて step モードを終了し、残りのタスクをすべて実行します。

en: Using the Ansible debugger
ja: Ansible デバッガーの使用

en: Controlling playbook execution: strategies and more
ja: Playbook の実行の制御: strategy など

en: By default, Ansible runs each task on all hosts affected by a play before starting the next task on any host, using 5 forks. If you want to change this default behavior, you can use a different strategy plugin, change the number of forks, or apply one of several keywords like ``serial``.
ja: デフォルトでは、Ansible はプレイの影響を受けるすべてのホストで各タスクを実行してから、任意のホストで次のタスクを開始し、5 つのフォークを使用します。このデフォルトの動作を変更する場合は、別のストラテジープラグインを使用するか、フォーク数を変更するか、``serial`` のようなキーワードのいずれかを適用することができます。

en: Selecting a strategy
ja: ストラテジーの選択

en: The default behavior described above is the :ref:`linear strategy<linear_strategy>`. Ansible offers other strategies, including the :ref:`debug strategy<debug_strategy>` (see also  :ref:`playbook_debugger`) and the :ref:`free strategy<free_strategy>`, which allows each host to run until the end of the play as fast as it can::
ja: 上述のデフォルトの動作は :ref:`線形ストラテジー<linear_strategy>` です。Ansible には、:ref:`デバッグストラテジー<debug_strategy>` (:ref:`playbook_debugger` も参照) や :ref:`フリーストラテジー<free_strategy>` など、他のストラテジーも用意されています。フリーストラテジーでは、各ホストがプレイが終了するまでできるだけ速く実行することができます。

en: You can select a different strategy for each play as shown above, or set your preferred strategy globally in ``ansible.cfg``, under the ``defaults`` stanza::
ja: 上記のように各プレイに異なるストラテジーを選択するか、``defaults`` stanza の ``ansible.cfg`` で優先されるストラテジーをグローバルに設定できます。

en: All strategies are implemented as :ref:`strategy plugins<strategy_plugins>`. Please review the documentation for each strategy plugin for details on how it works.
ja: すべてのストラテジーは :ref:`strategy プラグイン<strategy_plugins>` として実装されます。その仕組みの詳細は、各 strategy プラグインのドキュメントを参照してください。

en: Setting the number of forks
ja: フォークの数の設定

en: If you have the processing power available and want to use more forks, you can set the number in ``ansible.cfg``::
ja: 利用可能な処理能力があり、さらに多くのフォークを使用する場合は、``ansible.cfg`` で数値を設定できます。

en: or pass it on the command line: `ansible-playbook -f 30 my_playbook.yml`.
ja: または、コマンドラインで渡します (`ansible-playbook -f 30 my_playbook.yml`)。

en: Using keywords to control execution
ja: キーワードを使用した実行の制御

en: In addition to strategies, several :ref:`keywords<playbook_keywords>` also affect play execution. You can set a number, a percentage, or a list of numbers of hosts you want to manage at a time with ``serial``. Ansible completes the play on the specified number or percentage of hosts before starting the next batch of hosts. You can restrict the number of workers allotted to a block or task with ``throttle``. You can control how Ansible selects the next host in a group to execute against with ``order``. You can run a task on a single host with ``run_once``. These keywords are not strategies. They are directives or options applied to a play, block, or task.
ja: ストラテジーだけでなく、いくつかの :ref:`キーワード<playbook_keywords>` もプレイの実行に影響を与えます。``serial`` では、一度に管理したいホストの数、割合、またはリストを設定できます。Ansible は、指定した数または割合のホストでプレイを完了してから、次のホストのバッチを開始します。``throttle`` で、ブロックやタスクに割り当てられるワーカーの数を制限することができます。``order`` で、Ansible がグループ内の次のホストを選択して実行する方法を制御できます。``run_once`` を使用して、1 つのタスクを 1 つのホストで実行することができます。これらのキーワードはストラテジーではなく、プレイ、ブロック、またはタスクに適用されるディレクティブやオプションです。

en: Setting the batch size with ``serial``
ja: ``serial`` を使用してバッチサイズの設定

en: By default, Ansible runs in parallel against all the hosts in the :ref:`pattern <intro_patterns>` you set in the ``hosts:`` field of each play. If you want to manage only a few machines at a time, for example during a rolling update, you can define how many hosts Ansible should manage at a single time using the ``serial`` keyword::
ja: デフォルトでは、Ansible は、各プレイの ``hosts:`` フィールドで設定した :ref:`pattern <intro_patterns>` のすべてのホストに対して並行して実行します。ローリングアップデート中など、一度に数台のマシンのみを管理する場合は、``serial`` キーワードを使用して、Ansible が一度に管理するホストの数を定義できます。

en: In the above example, if we had 6 hosts in the group 'webservers', Ansible would execute the play completely (both tasks) on 3 of the hosts before moving on to the next 3 hosts::
ja: 上の例では、「webservers」というグループに 6 台のホストがあった場合、Ansible はそのうちの 3 台のホストでプレイを完全に (両方のタスクを) 実行してから、次の 3 台のホストに移ります。

en: You can also specify a percentage with the ``serial`` keyword. Ansible applies the percentage to the total number of hosts in a play to determine the number of hosts per pass::
ja: ``serial`` キーワードでパーセンテージを指定することもできます。Ansible は、プレイ内のホストの合計数にパーセンテージを適用して、パスごとのホスト数を決定します。

en: If the number of hosts does not divide equally into the number of passes, the final pass contains the remainder. In this example, if you had 20 hosts in the webservers group, the first batch would contain 6 hosts, the second batch would contain 6 hosts, the third batch would contain 6 hosts, and the last batch would contain 2 hosts.
ja: ホストの数がパスの数に等しく分配されない場合は、最後のパスには残りの数が含まれます。この例では、webservers グループに 20 台のホストがある場合、最初のバッチには 6 台のホストが、2 番目のバッチには 6 台のホストが、3 番目のバッチには 6 台のホストが、そして最後のバッチには 2 台のホストが含まれます。

en: You can also specify batch sizes as a list. For example::
ja: また、バッチサイズをリストとして指定することもできます。以下に例を示します。

en: In the above example, the first batch would contain a single host, the next would contain 5 hosts, and (if there are any hosts left), every following batch would contain either 10 hosts or all the remaining hosts, if fewer than 10 hosts remained.
ja: 上記の例では、最初のバッチには 1 台のホストが含まれ、次のバッチには 5 台のホストが含まれ、(ホストが残っていれば) その後のすべてのバッチには 10 台のホストが含まれるか、または 10 台未満のホストが残っていれば、残りのすべてのホストが含まれることになります。

en: You can list multiple batch sizes as percentages::
ja: 複数のバッチサイズをパーセンテージとして一覧表示できます。

en: You can also mix and match the values::
ja: 値を混在させたり、一致させることもできます。

en: No matter how small the percentage, the number of hosts per pass will always be 1 or greater.
ja: パーセンテージを小さくしても、各パスのホスト数は常に 1 以上になります。

en: Restricting execution with ``throttle``
ja: ``throttle`` で実行を制限

en: The ``throttle`` keyword limits the number of workers for a particular task. It can be set at the block and task level. Use ``throttle`` to restrict tasks that may be CPU-intensive or interact with a rate-limiting API::
ja: ``throttle`` キーワードは、特定のタスクに対するワーカーの数を制限します。これは、ブロックおよびタスクのレベルで設定できます。``throttle`` を使用して、CPU に負荷がかかる可能性のあるタスクや、レート制限 API と相互作用するタスクを制限します。

en: If you have already restricted the number of forks or the number of machines to execute against in parallel, you can reduce the number of workers with ``throttle``, but you cannot increase it. In other words, to have an effect, your ``throttle`` setting must be lower than your ``forks`` or ``serial`` setting if you are using them together.
ja: すでにフォークの数や並列実行するマシンの数を制限している場合は、``throttle`` でワーカーの数を減らすことはできますが、増やすことはできません。つまり、それを合わせて使用する場合に効果を得るためには、``throttle`` の設定が ``forks`` や ``serial`` の設定よりも低くなければなりません。

en: Ordering execution based on inventory
ja: インベントリーに基づく実行の順序付け

en: The ``order`` keyword controls the order in which hosts are run. Possible values for order are:
ja: ``order`` キーワードは、ホストが実行する順序を制御します。order に指定できる値は次のとおりです。

en: (default) The order provided in the inventory
ja: (デフォルト) インベントリーで指定する順序

en: The reverse of the order provided by the inventory
ja: インベントリーにより指定される順序の逆順

en: Sorted alphabetically sorted by name
ja: 名前をアルファベット順で並べ替えます。

en: Sorted by name in reverse alphabetical order
ja: アルファベットの逆順で名前がソートされます。

en: Randomly ordered on each run
ja: 実行ごとにランダムに順序付けられます。

en: Other keywords that affect play execution include ``ignore_errors``, ``ignore_unreachable``, and ``any_errors_fatal``. These options are documented in :ref:`playbooks_error_handling`.
ja: プレイの実行に影響する他のキーワードには、``ignore_errors``、``ignore_unreachable``、および ``any_errors_fatal`` が含まれます。これらのオプションは、「:ref:`playbooks_error_handling`」に記載されています。

en: Running on a single machine with ``run_once``
ja: シングルマシンで、``run_once`` で動作します。

en: If you want a task to run only on the first host in your batch of hosts, set ``run_once`` to true on that task::
ja: ホストのバッチの最初のホストでタスクを実行する場合は、そのタスクで ``run_once`` を true に設定します。

en: Ansible executes this task on the first host in the current batch and applies all results and facts to all the hosts in the same batch. This approach is similar to applying a conditional to a task such as::
ja: Ansible は、現在のバッチの最初のホストでこのタスクを実行し、すべての結果とファクトを同じバッチのすべてのホストに適用します。この方法は、次のような条件をタスクに適用することに似ています。

en: However, with ``run_once``, the results are applied to all the hosts. To run the task on a specific host, instead of the first host in the batch, delegate the task::
ja: ただし、``run_once`` では、結果はすべてのホストに適用されます。バッチの最初のホストではなく、特定のホストでタスクを実行するには、タスクを次のように委譲します。

en: As always with :ref:`delegation <playbooks_delegation>`, the action will be executed on the delegated host, but the information is still that of the original host in the task.
ja: :ref:`委譲 <playbooks_delegation>` の場合と同様、アクションは委譲されたホストで実行されますが、情報はタスクの元のホストの情報になります。

en: When used together with ``serial``, tasks marked as ``run_once`` will be run on one host in *each* serial batch. If the task must run only once regardless of ``serial`` mode, use :code:`when: inventory_hostname == ansible_play_hosts_all[0]` construct.
ja: ``serial`` と併用すると、``run_once`` とマークされたタスクは、*各* シリアルバッチの中の 1 台のホストで実行します。タスクが ``serial`` モードに関係なく 1 回だけ実行する必要がある場合は、:code:`when: inventory_hostname == ansible_play_hosts_all[0]` コンストラクトを使用します。

en: Any conditional (in other words, `when:`) will use the variables of the 'first host' to decide if the task runs or not, no other hosts will be tested.
ja: 条件 (つまり `when:`) は、「first host」の変数を使用して、タスクが実行されるかどうかを判断し、他のホストはテストされません。

en: If you want to avoid the default behavior of setting the fact for all hosts, set ``delegate_facts: True`` for the specific task or block.
ja: すべてのホストにファクトを設定するデフォルトの動作を回避する場合は、特定のタスクまたはブロックに ``delegate_facts: True`` を設定します。

en: Running tasks on or assigning facts to specific machines
ja: 特定マシンでのタスクの実行、または特定マシンへのファクトの割り当て

en: Tags
ja: タグ

en: If you have a large playbook, it may be useful to run only specific parts of it instead of running the entire playbook. You can do this with Ansible tags. Using tags to execute or skip selected tasks is a two-step process:
ja: 大規模な Playbook を使用する場合は、Playbook 全体を実行するのではなく、特定の部分だけを実行すると便利な場合があります。これを実現するには、Ansible のタグを使用します。タグを使用して選択したタスクを実行またはスキップするには、2 つのステップがあります。

en: Add tags to your tasks, either individually or with tag inheritance from a block, play, role, or import.
ja: タスクにタグを追加するには、個別にタグを追加するか、ブロック、プレイ、ロール、またはインポートからタグを継承する必要があります。

en: Select or skip tags when you run your playbook.
ja: Playbook の実行時にタグを選択またはスキップします。

en: Adding tags with the tags keyword
ja: tags キーワードを使用したタグの追加

en: You can add tags to a single task or include. You can also add tags to multiple tasks by defining them at the level of a block, play, role, or import. The keyword ``tags`` addresses all these use cases. The ``tags`` keyword always defines tags and adds them to tasks; it does not select or skip tasks for execution. You can only select or skip tasks based on tags at the command line when you run a playbook. See :ref:`using_tags` for more details.
ja: タグは、単一のタスクまたはインクルードに追加できます。また、ブロック、プレイ、ロール、またはインポートのレベルでタグを定義することで、複数のタスクにタグを追加することもできます。``tags`` キーワードは、これらすべてのユースケースに対応しています。``tags`` キーワードは、常にタグを定義してタスクに追加しますが、実行するタスクの選択やスキップは行いません。タグに基づいてタスクを選択またはスキップできるのは、Playbook の実行時にコマンドラインで行う場合のみです。詳細は、「:ref:`using_tags`」を参照してください。

en: Adding tags to individual tasks
ja: 個別タスクへのタグの追加

en: At the simplest level, you can apply one or more tags to an individual task. You can add tags to tasks in playbooks, in task files, or within a role. Here is an example that tags two tasks with different tags:
ja: 最も簡単なレベルでは、個々のタスクに 1 つまたは複数のタグを適用できます。タグは、Playbook 内、タスクファイル内、またはロール内のタスクに追加できます。以下は、2 つのタスクに異なるタグを付ける例です。

en: You can apply the same tag to more than one individual task. This example tags several tasks with the same tag, "ntp":
ja: 同じタグを複数の個別タスクに適用できます。この例では、同じタグ「ntp」を使用して、複数のタスクにタグを付けることができます。

en: If you ran these four tasks in a playbook with ``--tags ntp``, Ansible would run the three tasks tagged ``ntp`` and skip the one task that does not have that tag.
ja: ``--tags ntp`` を使用して、この 4 つのタスクを Playbook で実行した場合、Ansible は ``ntp`` のタグが付いた 3 つのタスクを実行し、タグが付いていない 1 つのタスクをスキップします。

en: Adding tags to includes
ja: インクルードするタグの追加

en: You can apply tags to dynamic includes in a playbook. As with tags on an individual task, tags on an ``include_*`` task apply only to the include itself, not to any tasks within the included file or role. If you add ``mytag`` to a dynamic include, then run that playbook with ``--tags mytag``, Ansible runs the include itself, runs any tasks within the included file or role tagged with ``mytag``, and skips any tasks within the included file or role without that tag. See :ref:`selective_reuse` for more details.
ja: タグは、Playbook 内の動的インクルードにタグを適用できます。個々のタスクのタグと同様に、``include_*`` タスクのタグは、インクルード自体にのみ適用され、インクルードされたファイルやロール内のタスクには適用されません。動的インクルードに ``mytag`` を追加し、その Playbook を ``--tags mytag`` で実行すると、Ansible はインクルード自体を実行し、``mytag`` でタグ付けされたインクルードファイルまたはロール内のタスクを実行し、そのタグのないインクルードファイルまたはロール内のタスクをスキップします。詳細は「:ref:`selective_reuse`」を参照してください。

en: You add tags to includes the same way you add tags to any other task:
ja: タグを追加して、他のタスクにタグを追加する方法と同じ方法でインクルードします。

en: You can add a tag only to the dynamic include of a role. In this example, the ``foo`` tag will `not` apply to tasks inside the ``bar`` role:
ja: タグは、ロールの動的インクルードにのみ追加できます。この例では、``foo`` タグは ``bar`` ロール内のタスクに適用 `されません`。

en: With plays, blocks, the ``role`` keyword, and static imports, Ansible applies tag inheritance, adding the tags you define to every task inside the play, block, role, or imported file. However, tag inheritance does *not* apply to dynamic re-use with ``include_role`` and ``include_tasks``. With dynamic re-use (includes), the tags you define apply only to the include itself. If you need tag inheritance, use a static import. If you cannot use an import because the rest of your playbook uses includes, see :ref:`apply_keyword` for ways to work around this behavior.
ja: プレイ、ブロック、``role`` キーワード、および静的なインポートでは、Ansible はタグ継承を適用し、定義したタグをプレイ、ブロック、ロール、またはインポートしたファイル内のすべてのタスクに追加します。しかし、``include_role`` や ``include_tasks`` のような動的再利用では、タグの継承は *適用されません*。動的再利用 (インクルード) では、定義したタグはインクルード自体にのみ適用されます。タグの継承が必要な場合は、静的インポートを使用してください。Playbook の他の部分がインクルードを使用しているためにインポートを使用できない場合は、この動作を回避する方法について「:ref:`apply_keyword`」を参照してください。

en: Tag inheritance: adding tags to multiple tasks
ja: タグの継承: 複数のタスクへのタグの追加

en: If you want to apply the same tag or tags to multiple tasks without adding a ``tags`` line to every task, you can define the tags at the level of your play or block, or when you add a role or import a file. Ansible applies the tags down the dependency chain to all child tasks. With roles and imports, Ansible appends the tags set by the ``roles`` section or import to any tags set on individual tasks or blocks within the role or imported file. This is called tag inheritance. Tag inheritance is convenient, because you do not have to tag every task. However, the tags still apply to the tasks individually.
ja: すべてのタスクに ``tags`` 行を追加することなく、複数のタスクに同じタグを適用したい場合は、プレイやブロックのレベル、またはロールの追加やファイルのインポートの際にタグを定義することができます。Ansible は、依存関係の連鎖の下にあるタグをすべての子タスクに適用します。ロールやインポートの場合、Ansible は ``roles`` セクションやインポートで設定されたタグを、ロールやインポートしたファイル内の個々のタスクやブロックに設定されたタグに追加します。これを「タグの継承」と呼びます。タグの継承は、すべてのタスクにタグを付ける必要がないため便利です。ただし、タグはタスクに個別に適用されます。

en: Adding tags to blocks
ja: ブロックへのタグの追加

en: If you want to apply a tag to many, but not all, of the tasks in your play, use a :ref:`block <playbooks_blocks>` and define the tags at that level. For example, we could edit the NTP example shown above to use a block:
ja: プレイ中のタスクのすべてではなく、多くのタスクにタグを適用したい場合は、:ref:`ブロック <playbooks_blocks>` を使用し、そのレベルでタグを定義します。たとえば、上で紹介した NTP の例を編集して、ブロックを使用することができます。

en: Adding tags to plays
ja: プレイへのタグの追加

en: If all the tasks in a play should get the same tag, you can add the tag at the level of the play. For example, if you had a play with only the NTP tasks, you could tag the entire play:
ja: プレイの中のすべてのタスクに同じタグを付ける必要がある場合は、プレイのレベルでタグを追加することができます。たとえば、NTP タスクだけのプレイがあった場合は、プレイ全体にタグを付けることができます。

en: Adding tags to roles
ja: ロールへのタグの追加

en: There are three ways to add tags to roles:
ja: ロールにタグを追加するには、3 つの方法があります。

en: Add the same tag or tags to all tasks in the role by setting tags under ``roles``. See examples in this section.
ja: ``roles`` セクションにタグを設定して、ロールのすべてのタスクに同じタグを追加します。本セクションの例を参照してください。

en: Add the same tag or tags to all tasks in the role by setting tags on a static ``import_role`` in your playbook. See examples in :ref:`tags_on_imports`.
ja: Playbook の静的 ``import_role`` にタグを設定して、ロール内のすべてのタスクに同じタグを追加します。「:ref:`tags_on_imports`」の例を参照してください。

en: Add a tag or tags to individual tasks or blocks within the role itself. This is the only approach that allows you to select or skip some tasks within the role. To select or skip tasks within the role, you must have tags set on individual tasks or blocks, use the dynamic ``include_role`` in your playbook, and add the same tag or tags to the include. When you use this approach, and then run your playbook with ``--tags foo``, Ansible runs the include itself plus any tasks in the role that also have the tag ``foo``. See :ref:`tags_on_includes` for details.
ja: ロール自体の中の個々のタスクやブロックにタグを追加します。これは、ロール内の一部のタスクを選択またはスキップすることができる唯一の方法です。ロール内のタスクを選択またはスキップするには、個々のタスクまたはブロックにタグを設定し、Playbook で動的な ``include_role`` を使用して、同じタグをインクルードに追加する必要があります。この方法で``--tags foo`` を付けて Playbook を実行すると、Ansible はインクルード自体に加えて、タグ ``foo`` を持つロール内のタスクを実行します。詳細は、「:ref:`tags_on_includes`」を参照してください。

en: When you incorporate a role in your playbook statically with the ``roles`` keyword, Ansible adds any tags you define to all the tasks in the role. For example:
ja: ``roles`` キーワードを使用して Playbook にロールを静的に組み込むと、Ansible は定義したタグをロール内のすべてのタスクに追加します。たとえば、以下のようになります。

en: or:
ja: または

en: Adding tags to imports
ja: インポートへのタグの追加

en: You can also apply a tag or tags to all the tasks imported by the static ``import_role`` and ``import_tasks`` statements:
ja: また、静的な ``import_role`` 文や ``import_tasks`` 文によりインポートされたすべてのタスクに、タグを適用することもできます。

en: Tag inheritance for includes: blocks and the ``apply`` keyword
ja: インクルードのタグ継承: ブロックおよび ``apply`` キーワード

en: By default, Ansible does not apply :ref:`tag inheritance <tag_inheritance>` to dynamic re-use with ``include_role`` and ``include_tasks``. If you add tags to an include, they apply only to the include itself, not to any tasks in the included file or role. This allows you to execute selected tasks within a role or task file - see :ref:`selective_reuse` when you run your playbook.
ja: デフォルトでは、Ansible は :ref:`タグ継承 <tag_inheritance>` を適用せず、``include_role`` および ``include_tasks`` を使用した動的再利用を行います。タグをインクルードに追加すると、タグはインクルード自体にのみ適用され、インクルードしたファイルやロール内のタスクには適用されません。これにより、ロールやタスクファイル内の選択したタスクを実行することができます。Playbook を実行する際には、「:ref:`selective_reuse`」を参照してください。

en: If you want tag inheritance, you probably want to use imports. However, using both includes and imports in a single playbook can lead to difficult-to-diagnose bugs. For this reason, if your playbook uses ``include_*`` to re-use roles or tasks, and you need tag inheritance on one include, Ansible offers two workarounds. You can use the ``apply`` keyword:
ja: タグの継承が必要な場合は、おそらくインポートを使用したいと思うでしょう。ただし、1 つの Playbook でインクルードとインポートの両方を使用すると、診断が困難なバグが発生する可能性があります。このような理由から、Playbook で ``include_*`` を使用してロールやタスクを再利用している場合に、1 つのインクルードでタグの継承が必要な場合、Ansible には 2 つの回避策があります。``apply`` キーワードを使用することができます。

en: Or you can use a block:
ja: または、以下のブロックを使用できます。

en: Special tags: always and never
ja: 特別なタグ: always および never

en: Ansible reserves two tag names for special behavior: always and never. If you assign the ``always`` tag to a task or play, Ansible will always run that task or play, unless you specifically skip it (``--skip-tags always``).
ja: Ansible は、特別な動作のために、always と never という 2 つのタグ名を予約しています。``always`` タグをタスクやプレイに割り当てると、Ansible は特にスキップしない限り、常にそのタスクやプレイを実行します (``--skip-tags always``)。

en: For example:
ja: たとえば、以下のようになります。

en: Fact gathering is tagged with 'always' by default. It is only skipped if you apply a tag and then use a different tag in ``--tags`` or the same tag in ``--skip-tags``.
ja: ファクト収集には、デフォルトで「always」というタグが付けられています。タグを適用した後、``--tags`` で別のタグを使用したり、``--skip-tags`` で同じタグを使用した場合に限りスキップされます。

en: The role argument specification validation task is tagged with 'always' by default. This validation will be skipped if you use ``--skip-tags always``.
ja: ロール引数の検証タスクは、デフォルトで「always」でタグ付けされます。``--skip-tags always`` を使用する場合は検証がスキップされます。

en: If you assign the ``never`` tag to a task or play, Ansible will skip that task or play unless you specifically request it (``--tags never``).
ja: ``never`` タグをタスクまたはプレイに割り当てると、特に要求しない限り (``--tags never``)、Ansible はそのタスクまたはプレイをスキップします。

en: The rarely-used debug task in the example above only runs when you specifically request the ``debug`` or ``never`` tags.
ja: 上記の例では、ほとんど使用されないデバッグタスクは、``debug`` タグまたは ``never`` タグを特別に要求した場合にのみ実行します。

en: Selecting or skipping tags when you run a playbook
ja: Playbook の実行時にタグの選択または省略

en: Once you have added tags to your tasks, includes, blocks, plays, roles, and imports, you can selectively execute or skip tasks based on their tags when you run :ref:`ansible-playbook`. Ansible runs or skips all tasks with tags that match the tags you pass at the command line. If you have added a tag at the block or play level, with ``roles``, or with an import, that tag applies to every task within the block, play, role, or imported role or file. If you have a role with lots of tags and you want to call subsets of the role at different times, either :ref:`use it with dynamic includes <selective_reuse>`, or split the role into multiple roles.
ja: タスク、インクルード、ブロック、プレイ、ロール、およびインポートにタグを追加したら、:ref:`ansible-playbook` を実行する際に、タグに基づいてタスクを選択的に実行またはスキップすることができます。Ansible は、コマンドラインで指定したタグと一致するタグを持つすべてのタスクを実行またはスキップします。ブロックやプレイのレベルで、``roles`` またはインポートを使用してタグを追加した場合、そのタグはブロック、プレイ、ロール、もしくはインポートされたロールまたはファイル内のすべてのタスクに適用されます。多くのタグを持つロールがあり、ロールのサブセットを異なるタイミングで呼び出したい場合は、:ref:`動的インクルードで使用する <selective_reuse>` か、ロールを複数のロールに分割してください。

en: :ref:`ansible-playbook` offers five tag-related command-line options:
ja: :ref:`ansible-playbook` は、タグ関連のコマンドラインオプションを 5 つ提供します。

en: ``--tags all`` - run all tasks, ignore tags (default behavior)
ja: ``--tags all`` - すべてのタスクを実行し、タグを無視します (デフォルトの動作)。

en: ``--tags [tag1, tag2]`` - run only tasks with either the tag ``tag1`` or the tag ``tag2``
ja: ``--tags [tag1, tag2]`` - ``tag1`` タグまたは ``tag2`` タグのいずれかでのみタスクを実行します。

en: ``--skip-tags [tag3, tag4]`` - run all tasks except those with either the tag ``tag3`` or the tag ``tag4``
ja: ``--skip-tags [tag3, tag4]`` - ``tag3`` タグまたは ``tag4`` タグのいずれかが指定されたタスク以外のすべてのタスクを実行します。

en: ``--tags tagged`` - run only tasks with at least one tag
ja: ``--tags tagged`` - 1 つ以上のタグでタスクのみを実行します。

en: ``--tags untagged`` - run only tasks with no tags
ja: ``--tags untagged`` - タグなしでタスクのみを実行します。

en: For example, to run only tasks and blocks tagged ``configuration`` and ``packages`` in a very long playbook:
ja: たとえば、非常に長い Playbook で、タスクと、``configuration`` および ``packages`` のタグが付けられたブロックのみを実行するには、以下のコマンドを実行します。

en: To run all tasks except those tagged ``packages``:
ja: ``packages`` のタグが付いたタスク以外のすべてのタスクを実行するには、以下を実行します。

en: Previewing the results of using tags
ja: タグの使用結果のプレビュー

en: When you run a role or playbook, you might not know or remember which tasks have which tags, or which tags exist at all. Ansible offers two command-line flags for :ref:`ansible-playbook` that help you manage tagged playbooks:
ja: ロールや Playbook を実行する際、どのタスクがどのタグを持っているのか、あるいはどのタグが存在するのかを知らない、あるいは覚えていない場合があります。Ansible では、タグ付き Playbookの管理に役立つ :ref:`ansible-playbook` にコマンドラインフラグを 2 つ提供しています。

en: ``--list-tags`` - generate a list of available tags
ja: ``--list-tags`` - 利用可能なタグのリストを生成します。

en: ``--list-tasks`` - when used with ``--tags tagname`` or ``--skip-tags tagname``, generate a preview of tagged tasks
ja: ``--list-tasks`` - ``--tags tagname`` または ``--skip-tags tagname`` と併用すると、タグ付けされたタスクのプレビューを生成します。

en: For example, if you do not know whether the tag for configuration tasks is ``config`` or ``conf`` in a playbook, role, or tasks file, you can display all available tags without running any tasks:
ja: たとえば、Playbook、ロール、またはタスクファイルの中で、設定タスクのタグが ``config`` か ``conf`` かがわからない場合は、タスクを実行せずに利用可能なタグをすべて表示することができます。

en: If you do not know which tasks have the tags ``configuration`` and ``packages``, you can pass those tags and add ``--list-tasks``. Ansible lists the tasks but does not execute any of them.
ja: ``configuration`` と ``packages`` のタグを持つタスクがわからない場合は、これらのタグを渡して ``--list-tasks`` を追加します。Ansible はタスクをリストアップしますが、実行はしません。

en: These command-line flags have one limitation: they cannot show tags or tasks within dynamically included files or roles. See :ref:`dynamic_vs_static` for more information on differences between static imports and dynamic includes.
ja: これらのコマンドラインフラグには、動的インクルードされたファイルやロール内のタグやタスクを表示することができないという制限があります。静的インポートと動的インクルードの違いについての詳細は、「:ref:`dynamic_vs_static`」を参照してください。

en: Selectively running tagged tasks in re-usable files
ja: 再利用可能なファイルでタグ付けされたタスクを選択的に実行

en: If you have a role or a tasks file with tags defined at the task or block level, you can selectively run or skip those tagged tasks in a playbook if you use a dynamic include instead of a static import. You must use the same tag on the included tasks and on the include statement itself. For example you might create a file with some tagged and some untagged tasks:
ja: タスクやブロックのレベルでタグが定義されているロールやタスクファイルがある場合は、静的インポートの代わりに動的インクルードを使用すると、Playbook 内のタグ付きタスクを選択的に実行したりスキップしたりすることができます。インクルードされるタスクと include 文自体には、同じタグを使用する必要があります。たとえば、タグ付きのタスクとタグなしのタスクを含むファイルを作成する場合は、以下のようになります。

en: And you might include the tasks file above in a playbook:
ja: また、Playbook に上記のタスクファイルを含めることができます。

en: When you run the playbook with ``ansible-playbook -i hosts myplaybook.yml --tags "mytag"``, Ansible skips the task with no tags, runs the tagged individual task, and runs the two tasks in the block.
ja: ``ansible-playbook -i hosts myplaybook.yml --tags "mytag"`` を使用して Playbook を実行すると、Ansible はタグのないタスクを省略し、タグ付けされた個別のタスクを実行し、ブロック内の 2 つのタスクを実行します。

en: Configuring tags globally
ja: タグのグローバル設定

en: If you run or skip certain tags by default, you can use the :ref:`TAGS_RUN` and :ref:`TAGS_SKIP` options in Ansible configuration to set those defaults.
ja: デフォルトで特定のタグを実行するか、スキップする場合は、Ansible 設定で :ref:`TAGS_RUN` オプションおよび :ref:`TAGS_SKIP` オプションを使用してこれらのデフォルトを設定できます。

en: Templating (Jinja2)
ja: テンプレート作成 (Jinja2)

en: Ansible uses Jinja2 templating to enable dynamic expressions and access to variables. Ansible includes a lot of specialized filters and tests for templating. You can use all the :ref:`standard filters and tests <jinja2:builtin-filters>` included in Jinja2 as well. Ansible also offers a new plugin type: :ref:`lookup_plugins`.
ja: Ansible は Jinja2 のテンプレートを使用して、動的な表現や変数へのアクセスを可能にしています。Ansible には、テンプレート化に特化したフィルターやテストが多数含まれています。Jinja2 に含まれる :ref:`標準フィルターおよびテスト <jinja2:builtin-filters>` もすべて使用することができます。また、Ansible では、新しいプラグインタイプ :ref:`lookup_plugins` も提供します。

en: All templating happens on the Ansible controller **before** the task is sent and executed on the target machine. This approach minimizes the package requirements on the target (jinja2 is only required on the controller). It also limits the amount of data Ansible passes to the target machine. Ansible parses templates on the controller and passes only the information needed for each task to the target machine, instead of passing all the data on the controller and parsing it on the target.
ja: テンプレート化はすべて、タスクが送信されターゲットマシンで実行する **前** に、Ansible のコントローラーで行われます。このアプローチにより、ターゲットでのパッケージ要件を最小限に抑えることができます (jinja2 はコントローラーでのみ必要です)。また、Ansible がターゲットマシンに渡すデータの量も制限されます。Ansible は、コントローラーですべてのデータを渡してターゲットで解析するのではなく、コントローラーでテンプレートを解析し、各タスクに必要な情報だけをターゲットマシンに渡します。

en: Get the current time
ja: 現在の時間を取得

en: The ``now()`` Jinja2 function retrieves a Python datetime object or a string representation for the current time.
ja: Jinja2 関数 ``now()`` は、Python の datetime オブジェクトまたは現在の時間を表す文字列を取得します。

en: The ``now()`` function supports 2 arguments:
ja: ``now()`` 関数は、2 つの引数をサポートします。

en: Specify ``True`` to get the current time in UTC. Defaults to ``False``.
ja: UTC で現在の時間を取得するには、``True`` を指定します。デフォルトは ``False`` です。

en: Accepts a `strftime <https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior>`_ string that returns a formatted date time string.
ja: `strftime <https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior>`_ の文字列を受け取り、形式化された日時文字列を返します。

en: Tests
ja: テスト

en: `Tests <http://jinja.pocoo.org/docs/dev/templates/#tests>`_ in Jinja are a way of evaluating template expressions and returning True or False. Jinja ships with many of these. See `builtin tests`_ in the official Jinja template documentation.
ja: Jinja の `テスト <http://jinja.pocoo.org/docs/dev/templates/#tests>`_ は、テンプレート式を評価して、True または False を返します。Jinja にはこれらの多くが同梱されています。Jinja の公式テンプレートドキュメントの「`builtin tests`_」をご覧ください。

en: The main difference between tests and filters are that Jinja tests are used for comparisons, whereas filters are used for data manipulation, and have different applications in jinja. Tests can also be used in list processing filters, like ``map()`` and ``select()`` to choose items in the list.
ja: テストとフィルターの主な違いは、Jinja のテストは比較に使用されるのに対し、フィルターはデータ操作に使用され、Jinja では用途が異なります。テストは、``map()`` や ``select()`` のように、リスト内の項目を選択するリスト処理フィルターにも使用できます。

en: Like all templating, tests always execute on the Ansible controller, **not** on the target of a task, as they test local data.
ja: すべてのテンプレートと同様、テストは常に、ローカルデータをテストする際にタスクのターゲットでは **なく**、Ansible コントローラーで実行されます。

en: In addition to those Jinja2 tests, Ansible supplies a few more and users can easily create their own.
ja: このような Jinja2 テストに加えて、Ansible はより多くのものを提供しており、ユーザーは独自のテストを簡単に作成できます。

en: Test syntax
ja: テストの構文

en: `Test syntax <http://jinja.pocoo.org/docs/dev/templates/#tests>`_ varies from `filter syntax <http://jinja.pocoo.org/docs/dev/templates/#filters>`_ (``variable | filter``). Historically Ansible has registered tests as both jinja tests and jinja filters, allowing for them to be referenced using filter syntax.
ja: `テストの構文 <http://jinja.pocoo.org/docs/dev/templates/#tests>` は、`フィルターの構文 <http://jinja.pocoo.org/docs/dev/templates/#filters>`_ (``variable | filter``) と異なります。これまで Ansible は、テストを jinja テストと jinja フィルターの両方に登録し、filter 構文を使用して参照できるようにしてきました。

en: As of Ansible 2.5, using a jinja test as a filter will generate a warning.
ja: Ansible 2.5 の時点では、jinja テストをフィルターとして使用すると警告が生成されます。

en: The syntax for using a jinja test is as follows::
ja: jinja テストを使用するための構文は、以下のとおりです。

en: Such as::
ja: 例::

en: Testing strings
ja: 文字列のテスト

en: To match strings against a substring or a regular expression, use the ``match``, ``search`` or ``regex`` tests::
ja: サブ文字列または正規表現に対して文字列と一致させるには、「``match``」、「``search``」、または「``regex``」を使用します。

en: ``match`` succeeds if it finds the pattern at the beginning of the string, while ``search`` succeeds if it finds the pattern anywhere within string. By default, ``regex`` works like ``search``, but ``regex`` can be configured to perform other tests as well, by passing the ``match_type`` keyword argument. In particular, ``match_type`` determines the ``re`` method that gets used to perform the search. The full list can be found in the relevant Python documentation `here <https://docs.python.org/3/library/re.html#regular-expression-objects>`_.
ja: ``match`` は、文字列の先頭でパターンを見つけた場合に成功し、``search`` は、文字列内の任意の場所でパターンを見つけた場合に成功します。デフォルトでは、``regex`` は ``search`` のように動作しますが、``regex`` は ``match_type`` キーワード引数を渡すことで、他のテストも実行するように構成することができます。特に、``match_type`` は、検索を実行する際に使用される ``re`` メソッドを決定します。完全なリストは、`こちら <https://docs.python.org/3/library/re.html#regular-expression-objects>`_ にある関連 Python ドキュメントを参照してください。

en: All of the string tests also take optional ``ignorecase`` and ``multiline`` arguments. These correspond to ``re.I`` and ``re.M`` from Python's ``re`` library, respectively.
ja: すべての文字列テストは、任意の ``ignorecase`` 引数および ``multiline`` 引数を取ります。これらは、Python の ``re`` ライブラリーからそれぞれ ``re.I`` および ``re.M`` に対応します。

en: You can test whether a variable is an inline single vault encrypted value using the ``vault_encrypted`` test.
ja: 変数がインラインの 1 つの vault で暗号化された値であるかどうかは、``vault_encrypted`` テストでテストできます。

en: Testing truthiness
ja: 真偽の検証

en: As of Ansible 2.10, you can now perform Python like truthy and falsy checks.
ja: Ansible 2.10 以降では、Python を真偽チェックのように実行できるようになりました。

en: Additionally, the ``truthy`` and ``falsy`` tests accept an optional parameter called ``convert_bool`` that will attempt to convert boolean indicators to actual booleans.
ja: また、``truthy`` テストおよび ``falsy`` テストは、ブール値インジケーターを実際のブール値に変換しようとする ``convert_bool`` と呼ばれる任意のパラメーターを受け入れます。

en: Comparing versions
ja: バージョンの比較

en: In 2.5 ``version_compare`` was renamed to ``version``
ja: 2.5 では、``version_compare`` の名前が ``version`` に変更されました。

en: To compare a version number, such as checking if the ``ansible_facts['distribution_version']`` version is greater than or equal to '12.04', you can use the ``version`` test.
ja: ``ansible_facts['distribution_version']`` のバージョンが「12.04」以上かどうかを確認するなど、バージョン番号を比較するには、``version`` テストを使用します。

en: The ``version`` test can also be used to evaluate the ``ansible_facts['distribution_version']``::
ja: ``version`` テストを使用して ``ansible_facts['distribution_version']`` を評価することもできます。

en: If ``ansible_facts['distribution_version']`` is greater than or equal to 12.04, this test returns True, otherwise False.
ja: ``ansible_facts['distribution_version']`` が 12.04 以上の場合は、このテストで True が返り、それ以外の場合は False が返ります。

en: The ``version`` test accepts the following operators::
ja: ``version`` テストでは、以下の演算子を受け入れます。

en: This test also accepts a 3rd parameter, ``strict`` which defines if strict version parsing as defined by ``distutils.version.StrictVersion`` should be used.  The default is ``False`` (using ``distutils.version.LooseVersion``), ``True`` enables strict version parsing::
ja: このテストは、3 番目のパラメーター ``strict`` も受け入れます。これは、``distutils.version.StrictVersion`` で定義された厳格なバージョン解析機能を使用できます。デフォルトは ``False`` (``distutils.version.LooseVersion`` を使用) で、``True`` は、厳格なバージョン解析を有効にします。

en: As of Ansible 2.11 the ``version`` test accepts a ``version_type`` parameter which is mutually exclusive with ``strict``, and accepts the following values::
ja: Ansible 2.11 の時点で、``version`` テストは ``strict`` と相互に排他的な ``version_type`` パラメーターを受け入れ、以下の値を受け入れます。

en: Using ``version_type`` to compare a semantic version would be achieved like the following::
ja: ``version_type`` を使用してセマンティックバージョンを比較すると、以下のように実行されます。

en: When using ``version`` in a playbook or role, don't use ``{{ }}`` as described in the `FAQ <https://docs.ansible.com/ansible/latest/reference_appendices/faq.html#when-should-i-use-also-how-to-interpolate-variables-or-dynamic-variable-names>`_::
ja: Playbook またはロールで ``version`` を使用する場合は、`FAQ <https://docs.ansible.com/ansible/latest/reference_appendices/faq.html#when-should-i-use-also-how-to-interpolate-variables-or-dynamic-variable-names>`_ で説明されているように ``{{ }}`` を使用しないでください。

en: Set theory tests
ja: セット理論テスト

en: In 2.5 ``issubset`` and ``issuperset`` were renamed to ``subset`` and ``superset``
ja: 2.5 では、``issubset`` および ``issuperset`` の名前が ``subset`` および ``superset`` に変更されました。

en: To see if a list includes or is included by another list, you can use 'subset' and 'superset'::
ja: リストに別のリストが含まれているか、またはリストが別のリストに含まれているかを確認するには、「subset」および「superset」を使用します。

en: Testing if a list contains a value
ja: リストに値が含まれるかどうかのテスト

en: Ansible includes a ``contains`` test which operates similarly, but in reverse of the Jinja2 provided ``in`` test. The ``contains`` test is designed to work with the ``select``, ``reject``, ``selectattr``, and ``rejectattr`` filters::
ja: Ansible には、Jinja2 が提供する ``in`` テストとは逆に、同様の動作をする ``contains`` テストが含まれています。``contains`` テストは、フィルターの ``select``、``reject``、``selectattr``、および ``rejectattr`` で動作するように設計されています。

en: Testing if a list value is True
ja: リスト値が True の場合のテスト

en: You can use `any` and `all` to check if any or all elements in a list are true or not::
ja: `any` および `all` を使用して、リスト内の一部またはすべての要素が true かどうかを確認できます。

en: Testing paths
ja: パスのテスト

en: In 2.5 the following tests were renamed to remove the ``is_`` prefix
ja: 2.5 では、以下のテストの名前が変更になり、``is_`` プレフィックスが削除されました。

en: The following tests can provide information about a path on the controller::
ja: 以下のテストは、コントローラー上のパスに関する情報を提供します。

en: Testing size formats
ja: サイズ形式のテスト

en: The ``human_readable`` and ``human_to_bytes`` functions let you test your playbooks to make sure you are using the right size format in your tasks, and that you provide Byte format to computers and human-readable format to people.
ja: ``human_readable`` 関数および ``human_to_bytes`` 関数を使用すると、Playbook をテストして、タスクで適切なサイズの形式を使用しているかどうか、また、コンピューターにはバイト形式、およびユーザーには人間が判読可能な形式を提供しているかどうかを確認することができます。

en: Human readable
ja: 人間が読み取り可能

en: Asserts whether the given string is human readable or not.
ja: 指定の文字列が人が判読できるかどうかをアサートします。

en: Human to bytes
ja: 人間からバイト

en: Returns the given string in the Bytes format.
ja: 指定した文字列をバイト形式で返します。

en: Testing task results
ja: タスク結果のテスト

en: The following tasks are illustrative of the tests meant to check the status of tasks::
ja: 以下のタスクは、タスクのステータスを確認するためのテストを示しています。

en: From 2.1, you can also use success, failure, change, and skip so that the grammar matches, for those who need to be strict about it.
ja: 2.1 以降、文法を厳密にする必要がある場合に、success、failure、change、および skip を使用して、文法が一致するようにすることもできます。

en: Using Variables
ja: 変数の使用

en: Ansible uses variables to manage differences between systems. With Ansible, you can execute tasks and playbooks on multiple different systems with a single command. To represent the variations among those different systems, you can create variables with standard YAML syntax, including lists and dictionaries. You can define these variables in your playbooks, in your :ref:`inventory <intro_inventory>`, in re-usable :ref:`files <playbooks_reuse>` or :ref:`roles <playbooks_reuse_roles>`, or at the command line. You can also create variables during a playbook run by registering the return value or values of a task as a new variable.
ja: Ansible は変数を使用してシステム間の違いを管理します。Ansible では、1 つのコマンドで複数の異なるシステム上でタスクや Playbook を実行することができます。これらの異なるシステム間の差異を表現するために、リストやディクショナリーなどの標準的な YAML 構文で変数を作成できます。これらの変数は、Playbook、:ref:`インベントリー <intro_inventory>`、再利用可能な :ref:`ファイル <playbooks_reuse>`、または :ref:`ロール <playbooks_reuse_roles>`、またはコマンドラインで定義できます。また、タスクの戻り値を新しい変数として登録することで、Playbook の実行中に変数を作成することもできます。

en: After you create variables, either by defining them in a file, passing them at the command line, or registering the return value or values of a task as a new variable, you can use those variables in module arguments, in :ref:`conditional "when" statements <playbooks_conditionals>`, in :ref:`templates <playbooks_templating>`, and in :ref:`loops <playbooks_loops>`. The `ansible-examples github repository <https://github.com/ansible/ansible-examples>`_ contains many examples of using variables in Ansible.
ja: ファイルで定義したり、コマンドラインで渡したり、タスクの戻り値を新しい変数として登録したりして変数を作成した後は、その変数をモジュールの引数、:ref:`conditional "when" statements <playbooks_conditionals>`、:ref:`templates <playbooks_templating>`、および :ref:`loops <playbooks_loops>` で使用することができます。`ansible-examples github repository <https://github.com/ansible/ansible-examples>`_ には、Ansible での変数の使用例が多数掲載されています。

en: Once you understand the concepts and examples on this page, read about :ref:`Ansible facts <vars_and_facts>`, which are variables you retrieve from remote systems.
ja: このページの概念と例を理解したら、リモートシステムから取得する変数である :ref:`Ansible facts <vars_and_facts>` を確認します。

en: Creating valid variable names
ja: 有効な変数名の作成

en: Not all strings are valid Ansible variable names. A variable name can only include letters, numbers, and underscores. `Python keywords`_ or :ref:`playbook keywords<playbook_keywords>` are not valid variable names. A variable name cannot begin with a number.
ja: すべての文字列が有効な Ansible の変数名になるわけではありません。変数名には、文字、数字、アンダースコアのみを含めることができます。`Python キーワード`_ または :ref:`playbook キーワード<playbook_keywords>` は有効な変数名ではありません。変数名は、数字で始めることはできません。

en: Variable names can begin with an underscore. In many programming languages, variables that begin with an underscore are private. This is not true in Ansible. Variables that begin with an underscore are treated exactly the same as any other variable. Do not rely on this convention for privacy or security.
ja: 変数名はアンダースコアで始めることができます。多くのプログラミング言語では、アンダースコアで始まる変数はプライベートです。Ansible ではこれは当てはまりません。アンダースコアで始まる変数は、他の変数とまったく同じように扱われます。プライバシーやセキュリティーのために、この規約に依存しないでください。

en: This table gives examples of valid and invalid variable names:
ja: この表は、有効かつ無効な変数名の例を紹介します。

en: Valid variable names
ja: 有効な変数名

en: Not valid
ja: 有効ではない

en: ``*foo``, `Python keywords`_ such as ``async`` and ``lambda``
ja: ``*foo``、`Python キーワード`_ (``async``、``lambda`` など)

en: :ref:`playbook keywords<playbook_keywords>` such as ``environment``
ja: ``environment`` などの :ref:`playbook キーワード<playbook_keywords>`

en: ``foo-port``, ``foo port``, ``foo.port``
ja: ``foo-port``、``foo port``、``foo.port``

en: ``foo5``, ``_foo``
ja: ``foo5``、``_foo``

en: ``5foo``, ``12``
ja: ``5foo``、``12``

en: Simple variables
ja: 単純な変数

en: Simple variables combine a variable name with a single value. You can use this syntax (and the syntax for lists and dictionaries shown below) in a variety of places. For details about setting variables in inventory, in playbooks, in reusable files, in roles, or at the command line, see :ref:`setting_variables`.
ja: 単純変数は、変数名と 1 つの値を組み合わせたものです。この構文 (および後述のリストやディレクトリーの構文) は、さまざまな場所で使用できます。インベントリー、Playbook、再利用可能なファイル、ロール、コマンドラインでの変数設定の詳細については、「:ref:`setting_variables`」を参照してください。

en: Defining simple variables
ja: 簡単な変数の定義

en: You can define a simple variable using standard YAML syntax. For example::
ja: 標準の YAML 構文を使用して単純な変数を定義できます。以下に例を示します。

en: Referencing simple variables
ja: 単純な変数の参照

en: After you define a variable, use Jinja2 syntax to reference it. Jinja2 variables use double curly braces. For example, the expression ``My amp goes to {{ max_amp_value }}`` demonstrates the most basic form of variable substitution. You can use Jinja2 syntax in playbooks. For example::
ja: 変数を定義した後は、Jinja2 の構文を使用して変数を参照します。Jinja2 の変数には二重の中括弧が使用されます。たとえば、``My amp goes to {{ max_amp_value }}`` という式は、最も基本的な形の変数置換を示しています。Playbook では、Jinja2 構文を使用できます。以下に例を示します。

en: In this example, the variable defines the location of a file, which can vary from one system to another.
ja: この例では、変数がファイルの場所を定義していますが、これはシステムごとに異なる可能性があります。

en: Ansible allows Jinja2 loops and conditionals in :ref:`templates <playbooks_templating>` but not in playbooks. You cannot create a loop of tasks. Ansible playbooks are pure machine-parseable YAML.
ja: Ansible では、:ref:`templates <playbooks_templating>` で Jinja2 のループや条件分岐を使用できますが、Playbook では使用できません。タスクのループを作成することはできません。Ansible の Playbook は純粋に機械で解析可能な YAML です。

en: When to quote variables (a YAML gotcha)
ja: 変数を引用するタイミング (YAML に関する注意点)

en: If you start a value with ``{{ foo }}``, you must quote the whole expression to create valid YAML syntax. If you do not quote the whole expression, the YAML parser cannot interpret the syntax - it might be a variable or it might be the start of a YAML dictionary. For guidance on writing YAML, see the :ref:`yaml_syntax` documentation.
ja: 値を ``{{ foo }}`` で始めた場合、有効な YAML 構文を作成するためには式全体を引用しなければなりません。式全体を引用符で囲まないと、YAML パーサーはその構文を解釈できません。それは変数かもしれないし、YAML ディレクトリーの始まりかもしれません。YAML の記述方法については、「:ref:`yaml_syntax`」のドキュメントを参照してください。

en: If you use a variable without quotes like this::
ja: 引用符なしの変数を使用する場合は、以下のようになります。

en: You will see: ``ERROR! Syntax Error while loading YAML.`` If you add quotes, Ansible works correctly::
ja: ``ERROR! Syntax Error while loading YAML.`` を参照してください。引用符を追加すると、Ansible が正常に機能します。

en: List variables
ja: リスト変数

en: A list variable combines a variable name with multiple values. The multiple values can be stored as an itemized list or in square brackets ``[]``, separated with commas.
ja: リスト変数は、変数名と複数の値を組み合わせたものです。複数の値は、項目別のリストとして、または角括弧 ``[]`` の中にコンマで区切って格納できます。

en: Defining variables as lists
ja: 変数をリストとして定義

en: You can define variables with multiple values using YAML lists. For example::
ja: YAML リストを使用して、複数の値で変数を定義できます。以下に例を示します。

en: Referencing list variables
ja: リスト変数の参照

en: When you use variables defined as a list (also called an array), you can use individual, specific fields from that list. The first item in a list is item 0, the second item is item 1. For example::
ja: リスト (配列とも呼ばれる) として定義された変数を使用する場合は、そのリストから個々の特定のフィールドを使用することができます。リストの最初の項目は項目 0、2 番目の項目は項目 1 です。以下に例を示します。

en: The value of this expression would be "northeast".
ja: この式の値は「northeast」になります。

en: Dictionary variables
ja: ディクショナリー変数

en: A dictionary stores the data in key-value pairs. Usually, dictionaries are used to store related data, such as the information contained in an ID or a user profile.
ja: ディクショナリーは、データをキーと値のペアに保存します。通常、ディクショナリーは ID またはユーザープロファイルに含まれる情報などの関連データを保存するために使用されます。

en: Defining variables as key:value dictionaries
ja: 変数を key:value ディクショナリーとして定義

en: You can define more complex variables using YAML dictionaries. A YAML dictionary maps keys to values.  For example::
ja: YAML ディクショナリーを使用してより複雑な変数を定義できます。YAML ディクショナリーはキーを値にマッピングします。以下に例を示します。

en: Referencing key:value dictionary variables
ja: key:value ディクショナリー変数の参照

en: When you use variables defined as a key:value dictionary (also called a hash), you can use individual, specific fields from that dictionary using either bracket notation or dot notation::
ja: key:value ディクショナリー (ハッシュとも呼ばれます) として定義された変数を使用する場合は、括弧表記またはドット表記のいずれかを使用して、そのディクショナリーの個々の特定のフィールドを使用できます。

en: Both of these examples reference the same value ("one"). Bracket notation always works. Dot notation can cause problems because some keys collide with attributes and methods of python dictionaries. Use bracket notation if you use keys which start and end with two underscores (which are reserved for special meanings in python) or are any of the known public attributes:
ja: これらの例では、どちらも同じ値 (「one」) を参照しています。括弧表記は常に有効です。ドット表記では、一部のキーが python ディクショナリーの属性やメソッドと衝突するため、問題が生じます。2 つのアンダースコアで始まって終わるキー (python では特別な意味を持つものとして予約されています) や、既知の公開属性を使用する場合は、括弧表記を使用してください。

en: ``add``, ``append``, ``as_integer_ratio``, ``bit_length``, ``capitalize``, ``center``, ``clear``, ``conjugate``, ``copy``, ``count``, ``decode``, ``denominator``, ``difference``, ``difference_update``, ``discard``, ``encode``, ``endswith``, ``expandtabs``, ``extend``, ``find``, ``format``, ``fromhex``, ``fromkeys``, ``get``, ``has_key``, ``hex``, ``imag``, ``index``, ``insert``, ``intersection``, ``intersection_update``, ``isalnum``, ``isalpha``, ``isdecimal``, ``isdigit``, ``isdisjoint``, ``is_integer``, ``islower``, ``isnumeric``, ``isspace``, ``issubset``, ``issuperset``, ``istitle``, ``isupper``, ``items``, ``iteritems``, ``iterkeys``, ``itervalues``, ``join``, ``keys``, ``ljust``, ``lower``, ``lstrip``, ``numerator``, ``partition``, ``pop``, ``popitem``, ``real``, ``remove``, ``replace``, ``reverse``, ``rfind``, ``rindex``, ``rjust``, ``rpartition``, ``rsplit``, ``rstrip``, ``setdefault``, ``sort``, ``split``, ``splitlines``, ``startswith``, ``strip``, ``swapcase``, ``symmetric_difference``, ``symmetric_difference_update``, ``title``, ``translate``, ``union``, ``update``, ``upper``, ``values``, ``viewitems``, ``viewkeys``, ``viewvalues``, ``zfill``.
ja: ``add``、``append``、``as_integer_ratio``、``bit_length``、``capitalize``、``center``、``clear``、``conjugate``、``copy``、``count``、``decode``、``denominator``、``difference``、``difference_update``、``discard``、``encode``、``endswith``、``expandtabs``、``extend``、``find``、``format``、``fromhex``、``fromkeys``、``get``、``has_key``、``hex``、``imag``、``index``、``insert``、``intersection``、``intersection_update``、``isalnum``、``isalpha``、``isdecimal``、``isdigit``、``isdisjoint``、``is_integer``、``islower``、``isnumeric``、``isspace``、``issubset``、``issuperset``、``istitle``、``isupper``、``items``、``iteritems``、``iterkeys``、``itervalues``、``join``、``keys``、``ljust``、``lower``、``lstrip``、``numerator``、``partition``、``pop``、``popitem``、``real``、``remove``、``replace``、``reverse``、``rfind``、``rindex``、``rjust``、``rpartition``、``rsplit``、``rstrip``、``setdefault``、``sort``、``split``、``splitlines``、``startswith``、``strip``、``swapcase``、``symmetric_difference``、``symmetric_difference_update``、``title``、``translate``、``union``、``update``、``upper``、``values``、``viewitems``、``viewkeys``、``viewvalues``、``zfill``

en: Registering variables
ja: 変数の登録

en: You can create variables from the output of an Ansible task with the task keyword ``register``. You can use registered variables in any later tasks in your play. For example::
ja: タスクキーワード ``register`` を使用して、Ansible タスクの出力から変数を作成することができます。登録した変数は、プレイ中の後続のタスクで使用することができます。以下に例を示します。

en: For more examples of using registered variables in conditions on later tasks, see :ref:`playbooks_conditionals`. Registered variables may be simple variables, list variables, dictionary variables, or complex nested data structures. The documentation for each module includes a ``RETURN`` section describing the return values for that module. To see the values for a particular task, run your playbook with ``-v``.
ja: 登録された変数を後のタスクの条件で使用する例は、「:ref:`playbooks_conditionals`」を参照してください。登録した変数には、単純な変数、リスト変数、ディクショナリー変数、複雑にネストしたデータ構造などがあります。各モジュールのドキュメントには、そのモジュールの戻り値を説明した ``RETURN`` セクションがあります。特定のタスクの値を確認するには、``-v`` で Playbook を実行します。

en: Registered variables are stored in memory. You cannot cache registered variables for use in future plays. Registered variables are only valid on the host for the rest of the current playbook run.
ja: 登録された変数はメモリーに保存されます。登録された変数を将来のプレイで使用するためにキャッシュすることはできません。登録された変数は、現在の Playbook の残りの実行中、ホスト上でのみ有効です。

en: Registered variables are host-level variables. When you register a variable in a task with a loop, the registered variable contains a value for each item in the loop. The data structure placed in the variable during the loop will contain a ``results`` attribute, that is a list of all responses from the module. For a more in-depth example of how this works, see the :ref:`playbooks_loops` section on using register with a loop.
ja: 登録された変数は、ホストレベルの変数です。ループのあるタスクで変数を登録すると、登録された変数にはループ内の各項目の値が入ります。ループ中に変数に置かれたデータ構造には、``results`` 属性、つまりモジュールからの全応答のリストが含まれます。この動作の詳細な例については、ループで登録の使用に関する「:ref:`playbooks_loops`」セクションを参照してください。

en: If a task fails or is skipped, Ansible still registers a variable with a failure or skipped status, unless the task is skipped based on tags. See :ref:`tags` for information on adding and using tags.
ja: タスクが失敗またはスキップしても、タグに基づいてタスクがスキップされていない限り、Ansible は失敗またはスキップのステータスで変数を登録します。タグの追加および使用に関する情報は、「:ref:`tags`」を参照してください。

en: Referencing nested variables
ja: ネストされた変数の参照

en: Many registered variables (and :ref:`facts <vars_and_facts>`) are nested YAML or JSON data structures. You cannot access values from these nested data structures with the simple ``{{ foo }}`` syntax. You must use either bracket notation or dot notation. For example, to reference an IP address from your facts using the bracket notation::
ja: 多くの登録された変数 (および :ref:`facts <vars_and_facts>`) は、ネストされた YAML または JSON データ構造です。これらのネストしたデータ構造の値には、単純な ``{{ foo }}`` の構文ではアクセスできません。括弧表記またはドット表記のいずれかを使用する必要があります。たとえば、括弧表記を使用してファクトから IP アドレスを参照するには、以下を行います。

en: To reference an IP address from your facts using the dot notation::
ja: ドット表記を使用してファクトから IP アドレスを参照するには、以下を実行します。

en: Transforming variables with Jinja2 filters
ja: Jinja2 フィルターを使用した変数の変換

en: Jinja2 filters let you transform the value of a variable within a template expression. For example, the ``capitalize`` filter capitalizes any value passed to it; the ``to_yaml`` and ``to_json`` filters change the format of your variable values. Jinja2 includes many `built-in filters <https://jinja.palletsprojects.com/templates/#builtin-filters>`_ and Ansible supplies many more filters. To find more examples of filters, see :ref:`playbooks_filters`.
ja: Jinja2 のフィルターは、テンプレート式内の変数の値を変換することができます。たとえば、``capitalize`` フィルターは、渡された値をすべて大文字にします。``to_yaml`` フィルターおよび ``to_json`` フィルターは、変数の値の形式を変更します。Jinja2 には多くの `built-in フィルター <https://jinja.palletsprojects.com/templates/#builtin-filters>`_ があり、Ansible にはさらに多くのフィルターが用意されています。フィルターのその他の例については、「:ref:`playbooks_filters`」を参照してください。

en: Where to set variables
ja: 変数を設定する場所

en: You can define variables in a variety of places, such as in inventory, in playbooks, in reusable files, in roles, and at the command line. Ansible loads every possible variable it finds, then chooses the variable to apply based on :ref:`variable precedence rules <ansible_variable_precedence>`.
ja: 変数は、インベントリー、Playbook、再利用可能ファイル、ロール、コマンドラインなど、さまざまな場所で定義することができます。Ansible は、検出可能なすべての変数を読み込み、:ref:`変数の優先順位ルール <ansible_variable_precedence>` に基づいて適用する変数を選択します。

en: Defining variables in inventory
ja: インベントリーでの変数の定義

en: You can define different variables for each individual host, or set shared variables for a group of hosts in your inventory. For example, if all machines in the ``[Boston]`` group use 'boston.ntp.example.com' as an NTP server, you can set a group variable. The :ref:`intro_inventory` page has details on setting :ref:`host variables <host_variables>` and :ref:`group variables <group_variables>` in inventory.
ja: 個々のホストごとに異なる変数を定義したり、インベントリー内のホストグループに共有変数を設定することができます。たとえば、``[Boston]`` グループのすべてのマシンが NTP サーバーとして「boston.ntp.example.com」を使用する場合は、グループ変数を設定することができます。:ref:`intro_inventory` ページには、インベントリーで :ref:`host variables <host_variables>` および :ref:`group variables <group_variables>` を設定するための詳細が記載されています。

en: Defining variables in a play
ja: プレイでの変数の定義

en: You can define variables directly in a playbook play::
ja: 変数は Playbook プレイで直接定義できます。

en: When you define variables in a play, they are only visible to tasks executed in that play.
ja: プレイで変数を定義すると、そのプレイで実行しているタスクでのみ表示されます。

en: Defining variables in included files and roles
ja: インクルードファイルおよびロールでの変数の定義

en: You can define variables in reusable variables files and/or in reusable roles. When you define variables in reusable variable files, the sensitive variables are separated from playbooks. This separation enables you to store your playbooks in a source control software and even share the playbooks, without the risk of exposing passwords or other sensitive and personal data. For information about creating reusable files and roles, see :ref:`playbooks_reuse`.
ja: 変数は、再利用可能な変数ファイルや再利用可能なロールに定義することができます。再利用可能な変数ファイルに変数を定義すると、機密性の高い変数が Playbook から分離されます。この分離により、パスワードなどの機密情報や個人情報を流出させることなく、ソースコントロールソフトウェアに Playbook を保存したり、Playbook を共有したりすることができます。再利用可能なファイルやロールの作成は、「:ref:`playbooks_reuse`」を参照してください。

en: This example shows how you can include variables defined in an external file::
ja: この例は、外部ファイルで定義された変数を追加する方法を示しています。

en: The contents of each variables file is a simple YAML dictionary. For example::
ja: 各変数ファイルの内容は、単純な YAML ディクショナリーです。以下に例を示します。

en: You can keep per-host and per-group variables in similar files. To learn about organizing your variables, see :ref:`splitting_out_vars`.
ja: ホスト別およびグループ別の変数を同様のファイルに維持することができます。変数を整理する方法は、「:ref:`splitting_out_vars`」を参照してください。

en: Defining variables at runtime
ja: ランタイム時の変数の定義

en: You can define variables when you run your playbook by passing variables at the command line using the ``--extra-vars`` (or ``-e``) argument. You can also request user input with a ``vars_prompt`` (see :ref:`playbooks_prompts`). When you pass variables at the command line, use a single quoted string, that contains one or more variables, in one of the formats below.
ja: Playbook の実行時に変数を定義するには、コマンドラインで ``--extra-vars`` (または ``-e``) 引数を使用して変数を渡します。また、``vars_prompt`` (:ref:`playbooks_prompts` 参照) でユーザーの入力を要求することもできます。コマンドラインで変数を渡すときは、以下のいずれかの形式で、1 つまたは複数の変数を含む一重引用符で囲まれた文字列を使用します。

en: key=value format
ja: key=value 形式

en: Values passed in using the ``key=value`` syntax are interpreted as strings. Use the JSON format if you need to pass non-string values such as Booleans, integers, floats, lists, and so on.
ja: ``key=value`` 構文を使用して渡される値は文字列として解釈されます。ブール値、整数、浮動小数点、リストなど、文字列以外の値を渡す必要がある場合は、JSON 形式を使用します。

en: JSON string format
ja: JSON 文字列の形式

en: When passing variables with ``--extra-vars``, you must escape quotes and other special characters appropriately for both your markup (for example, JSON), and for your shell::
ja: ``--extra-vars`` で変数を渡す場合には、マークアップ (JSON など) とシェルの両方で、引用符やその他の特殊文字を適切にエスケープする必要があります。

en: If you have a lot of special characters, use a JSON or YAML file containing the variable definitions.
ja: 特殊文字が多数ある場合は、変数定義を含む JSON ファイルまたは YAML ファイルを使用します。

en: vars from a JSON or YAML file
ja: JSON ファイルまたは YAML ファイルの変数

en: Variable precedence: Where should I put a variable?
ja: 変数の優先順位: 変数をどこに置くべきか

en: You can set multiple variables with the same name in many different places. When you do this, Ansible loads every possible variable it finds, then chooses the variable to apply based on variable precedence. In other words, the different variables will override each other in a certain order.
ja: 同じ名前の複数の変数をさまざまな場所に設定することができます。これを行うと、Ansible は検出可能なすべての変数を読み込み、次に変数の優先順位に基づいて適用する変数を選択します。つまり、異なる変数が一定の順序で互いに上書きされます。

en: Teams and projects that agree on guidelines for defining variables (where to define certain types of variables) usually avoid variable precedence concerns. We suggest that you define each variable in one place: figure out where to define a variable, and keep it simple. For examples, see :ref:`variable_examples`.
ja: 変数の定義に関するガイドライン (特定のタイプの変数をどこで定義するか) に合意したチームやプロジェクトは、通常、変数の優先順位に関する懸念を回避することができます。各変数は、一箇所で定義することが推奨されます。どこで変数を定義するかを把握し、簡潔さを保ってください。例については、「:ref:`variable_examples`」を参照してください。

en: Some behavioral parameters that you can set in variables you can also set in Ansible configuration, as command-line options, and using playbook keywords. For example, you can define the user Ansible uses to connect to remote devices as a variable with ``ansible_user``, in a configuration file with ``DEFAULT_REMOTE_USER``, as a command-line option with ``-u``, and with the playbook keyword ``remote_user``. If you define the same parameter in a variable and by another method, the variable overrides the other setting. This approach allows host-specific settings to override more general settings. For examples and more details on the precedence of these various settings, see :ref:`general_precedence_rules`.
ja: 変数で設定できる動作パラメーターの中には、Ansible の構成、コマンドラインオプション、および Playbook キーワードで設定できるものがあります。たとえば、Ansible がリモートデバイスへの接続に使用するユーザーは、変数では ``ansible_user``、構成ファイルでは``DEFAULT_REMOTE_USER``、コマンドラインオプションでは ``-u`` 、Playbook キーワードでは ``remote_user`` で定義できます。変数と別の方法で同じパラメーターを定義した場合は、変数が別の設定を上書きします。この方法では、ホスト固有の設定がより一般的な設定を上書きします。これらのさまざまな設定の優先順位の例や詳細は、「:ref:`general_precedence_rules`」を参照してください。

en: Understanding variable precedence
ja: 変数の優先順位について

en: Ansible does apply variable precedence, and you might have a use for it. Here is the order of precedence from least to greatest (the last listed variables override all other variables):
ja: Ansible では変数の優先順位を適用しており、それを利用できる場合があります。ここでは、優先順位の低いものから高いものまでを紹介します (最後に挙げた変数が他のすべての変数を上書きします)。

en: command line values (for example, ``-u my_user``, these are not variables)
ja: コマンドラインの値 (例: ``-u my_user`` (これらは変数ではありません))

en: role defaults (defined in role/defaults/main.yml) [1]_
ja: ロールのデフォルト(role/defaults/main.yml で定義) [1]_

en: inventory file or script group vars [2]_
ja: インベントリーファイルまたはスクリプトのグループ変数 [2]_

en: inventory group_vars/all [3]_
ja: インベントリー group_vars/all [3]_

en: inventory group_vars/* [3]_
ja: インベントリー group_vars/* [3]_

en: inventory file or script host vars [2]_
ja: インベントリーファイルまたはスクリプトホスト変数 [2]_

en: inventory host_vars/* [3]_
ja: インベントリー host_vars/* [3]_

en: host facts / cached set_facts [4]_
ja: ホストファクト / キャッシュ済み set_facts [4]_

en: play vars
ja: プレイ変数

en: role vars (defined in role/vars/main.yml)
ja: role 変数 (role/vars/main.yml で定義)

en: block vars (only for tasks in block)
ja: ブロック変数 (ブロックのタスクにのみ適用)

en: task vars (only for the task)
ja: タスク変数 (タスク専用)

en: set_facts / registered vars
ja: set_facts / 登録変数

en: role (and include_role) params
ja: role (および include_role) パラメーター

en: include params
ja: include パラメーター

en: extra vars (for example, ``-e "user=my_user"``)(always win precedence)
ja: 追加の変数 (例: ``-e "user=my_user"``)(常に優先されます)

en: In general, Ansible gives precedence to variables that were defined more recently, more actively, and with more explicit scope. Variables in the defaults folder inside a role are easily overridden. Anything in the vars directory of the role overrides previous versions of that variable in the namespace. Host and/or inventory variables override role defaults, but explicit includes such as the vars directory or an ``include_vars`` task override inventory variables.
ja: 一般的に、Ansible は、より新しく、より積極的に、より明確なスコープで定義された変数を優先します。ロール内の defaults フォルダーにある変数は簡単に上書きされます。ロールの vars ディレクトリーにあるものは、名前空間内のその変数の以前のバージョンを上書きします。ホストおよび/またはインベントリー変数はロールのデフォルトを上書きしますが、vars ディレクトリーや ``include_vars`` タスクなどの明示的なインクルードはインベントリー変数を上書きします。

en: Ansible merges different variables set in inventory so that more specific settings override more generic settings. For example, ``ansible_ssh_user`` specified as a group_var is overridden by ``ansible_user`` specified as a host_var. For details about the precedence of variables set in inventory, see :ref:`how_we_merge`.
ja: Ansible は、インベントリーに設定した異なる変数をマージして、より特定の設定がより一般的な設定を上書きするようにします。たとえば、group_var として指定した ``ansible_ssh_user`` は、host_var として指定した ``ansible_user`` により上書きされます。インベントリーで設定された変数の優先順位の詳細については、「:ref:`how_we_merge`」を参照してください。

en: Footnotes
ja: 注記

en: Tasks in each role see their own role's defaults. Tasks defined outside of a role see the last role's defaults.
ja: 各ロールのタスクには、それぞれのロールのデフォルト値が表示されます。ロールの外で定義されたタスクには、最後のロールのデフォルトが表示されます。

en: Variables defined in inventory file or provided by dynamic inventory.
ja: インベントリーファイルで定義される変数、または動的インベントリーで指定される変数。

en: Includes vars added by 'vars plugins' as well as host_vars and group_vars which are added by the default vars plugin shipped with Ansible.
ja: 「vars プラグイン」と、Ansible に同梱されるデフォルトの vars プラグインにより追加される host_vars および group_vars が含まれるインクルード変数。

en: When created with set_facts's cacheable option, variables have the high precedence in the play, but are the same as a host facts precedence when they come from the cache.
ja: set_facts のキャッシュ可能なオプションを使用して作成すると、変数がプレイに優先されますが、キャッシュからのホストのファクトと同様に優先されます。

en: Within any section, redefining a var overrides the previous instance. If multiple groups have the same variable, the last one loaded wins. If you define a variable twice in a play's ``vars:`` section, the second one wins.
ja: どのセクションでも、変数を再定義すると前のインスタンスが上書きされます。複数のグループが同じ変数を持っている場合は、最後に読み込まれたものが優先されます。プレイ中の ``vars:`` のセクションで変数を 2 回定義した場合は、2 回目の変数が優先されます。

en: The previous describes the default config ``hash_behaviour=replace``, switch to ``merge`` to only partially overwrite.
ja: 以前は、デフォルトの設定 ``hash_behaviour=replace`` を説明し、``merge`` に切り替えてを部分的に上書きします。

en: Scoping variables
ja: 変数のスコープ設定

en: You can decide where to set a variable based on the scope you want that value to have. Ansible has three main scopes:
ja: 変数をどこに設定するかは、その値が持つべきスコープに基づいて決めることができます。Ansible には大きく分けて 3 つのスコープがあります。

en: Global: this is set by config, environment variables and the command line
ja: グローバル: これは、設定、環境変数、およびコマンドラインで設定されます。

en: Play: each play and contained structures, vars entries (vars; vars_files; vars_prompt), role defaults and vars.
ja: プレイ: 各プレイおよび含まれる構造、変数エントリー (vars、vars_files、vars_prompt)、ロールのデフォルトおよび変数。

en: Host: variables directly associated to a host, like inventory, include_vars, facts or registered task outputs
ja: ホスト: インベントリー、include_vars、ファクト、または登録されたタスクの出力などのホストに直接関連付けられる変数

en: Inside a template, you automatically have access to all variables that are in scope for a host, plus any registered variables, facts, and magic variables.
ja: テンプレート内では、ホストのスコープ内にあるすべての変数と、登録済みの変数、ファクト、およびマジック変数に自動的にアクセスできます。

en: Tips on where to set variables
ja: 変数を設定する場所に関するヒント

en: You should choose where to define a variable based on the kind of control you might want over values.
ja: 変数を定義する場所は、値をどのように制御するかによって選択する必要があります。

en: Set variables in inventory that deal with geography or behavior. Since groups are frequently the entity that maps roles onto hosts, you can often set variables on the group instead of defining them on a role. Remember: child groups override parent groups, and host variables override group variables. See :ref:`define_variables_in_inventory` for details on setting host and group variables.
ja: 地理や動作を扱うインベントリーに変数を設定します。グループは、ホストにロールをマッピングするエンティティーであることが多いため、ロールに変数を定義する代わりに、グループに変数を設定することができます。子グループが親グループを上書きし、ホスト変数がグループ変数を上書きすることを忘れないでください。ホスト変数とグループ変数の設定の詳細は、「:ref:`define_variables_in_inventory`」を参照してください。

en: Set common defaults in a ``group_vars/all`` file. See :ref:`splitting_out_vars` for details on how to organize host and group variables in your inventory. Group variables are generally placed alongside your inventory file, but they can also be returned by dynamic inventory (see :ref:`intro_dynamic_inventory`) or defined in :ref:`ansible_tower` from the UI or API::
ja: ``group_vars/all`` ファイルで共通のデフォルトを設定します。インベントリーでホスト変数とグループ変数を整理する方法の詳細については、「:ref:`splitting_out_vars`」を参照してください。グループ変数は通常、インベントリーファイルと一緒に置かれますが、動的インベントリー (:ref:`intro_dynamic_inventory` を参照) で返されたり、UI や API から :ref:`ansible_tower` で定義することもできます。

en: Set location-specific variables in ``group_vars/my_location`` files. All groups are children of the ``all`` group, so variables set here override those set in ``group_vars/all``::
ja: ``group_vars/my_location`` ファイルにロケーション固有の変数を設定します。すべてのグループは ``all`` グループの子であるため、ここに設定される変数は ``group_vars/all`` で設定した変数を上書きします。

en: If one host used a different NTP server, you could set that in a host_vars file, which would override the group variable::
ja: 1 つのホストが別の NTP サーバーを使用している場合は、host_vars ファイルにそのホストを設定できます。これにより、グループ変数が上書きされます。

en: Set defaults in roles to avoid undefined-variable errors. If you share your roles, other users can rely on the reasonable defaults you added in the ``roles/x/defaults/main.yml`` file, or they can easily override those values in inventory or at the command line. See :ref:`playbooks_reuse_roles` for more info. For example::
ja: 未定義な変数エラーを防ぐために、ロールにデフォルト値を設定します。ロールを共有している場合、他のユーザーは、``roles/x/defaults/main.yml`` ファイルで追加した妥当なデフォルト値を信頼するか、インベントリーやコマンドラインで簡単にその値を上書きすることができます。詳細は、「:ref:`playbooks_reuse_roles`」を参照してください。以下に例を示します。

en: Set variables in roles to ensure a value is used in that role, and is not overridden by inventory variables. If you are not sharing your role with others, you can define app-specific behaviors like ports this way, in ``roles/x/vars/main.yml``. If you are sharing roles with others, putting variables here makes them harder to override, although they still can by passing a parameter to the role or setting a variable with ``-e``::
ja: ロールに変数を設定することで、値がそのロールで使用され、インベントリー変数で上書きされないようにします。ロールを他の人と共有していない場合は、ポートなどのアプリ固有の動作を、このように ``roles/x/vars/main.yml`` で定義できます。他の人とロールを共有している場合は、ここに変数を置くことで上書きされにくくなります。ただし、ロールにパラメーターを渡したり、``-e`` で変数を設定したりすれば、上書きされる可能性はあります。

en: Pass variables as parameters when you call roles for maximum clarity, flexibility, and visibility. This approach overrides any defaults that exist for a role. For example::
ja: 明確さ、柔軟性、および可視性を最大化するためにロールを呼び出す場合は、パラメーターとして変数を渡します。この方法では、ロールに存在するデフォルトを上書きします。以下に例を示します。

en: When you read this playbook it is clear that you have chosen to set a variable or override a default. You can also pass multiple values, which allows you to run the same role multiple times. See :ref:`run_role_twice` for more details. For example::
ja: この Playbook を読むと、変数の設定やデフォルトの上書きを選択したことがわかります。また、複数の値を渡すことができるため、同じロールを複数回実行することができます。詳細は「:ref:`run_role_twice`」を参照してください。以下に例を示します。

en: Variables set in one role are available to later roles. You can set variables in a ``roles/common_settings/vars/main.yml`` file and use them in other roles and elsewhere in your playbook::
ja: 1 つのロールに設定された変数は、後のロールで使用できます。変数は、``roles/common_settings/vars/main.yml`` ファイルに設定して、他のロールや Playbook の他の場所で使用します。

en: There are some protections in place to avoid the need to namespace variables. In this example, variables defined in 'common_settings' are available to 'something' and 'something_else' tasks, but tasks in 'something' have foo set at 12, even if 'common_settings' sets foo to 20.
ja: 変数の名前空間化の必要性を回避するために、いくつかの保護機能があります。この例では、「common_settings」で定義された変数は「something」と「something_else」のタスクで使用できますが、「common_settings」で foo が 20 に設定されていても、「something」のタスクでは foo が 12 に設定されています。

en: Instead of worrying about variable precedence, we encourage you to think about how easily or how often you want to override a variable when deciding where to set it. If you are not sure what other variables are defined, and you need a particular value, use ``--extra-vars`` (``-e``) to override all other variables.
ja: 変数の優先順位を気にするのではなく、変数をどこに設定するかを決める際には、どれだけ簡単に、あるいはどれだけ頻繁に変数を上書きしたいかを考えることが推奨されます。他の変数がどのように定義されているかわからず、特定の値が必要な場合は、``--extra-vars`` (``-e``) を使用して、他のすべての変数を上書きします。

en: Using advanced variable syntax
ja: 高度な変数構文の使用

en: For information about advanced YAML syntax used to declare variables and have more control over the data placed in YAML files used by Ansible, see :ref:`playbooks_advanced_syntax`.
ja: 変数を宣言するのに使用される高度な YAML 構文、および Ansible により使用される YAML ファイルにあるデータに対する制御の詳細は、「:ref:`playbooks_advanced_syntax`」を参照してください。

en: Jinja2 filters and their uses
ja: Jinja2 フィルターおよびその使用

en: List of special variables
ja: 特殊な変数のリスト

en: Discovering variables: facts and magic variables
ja: 変数の検出: ファクトおよびマジック変数

en: With Ansible you can retrieve or discover certain variables containing information about your remote systems or about Ansible itself. Variables related to remote systems are called facts. With facts, you can use the behavior or state of one system as configuration on other systems. For example, you can use the IP address of one system as a configuration value on another system. Variables related to Ansible are called magic variables.
ja: Ansible では、リモートシステムや Ansible 自体に関する情報を含む特定の変数を取得または検出を行うことができます。リモートシステムに関連する変数をファクトと呼びます。ファクトを使用すると、あるシステムの動作や状態を他のシステムの設定値として使用することができます。たとえば、あるシステムの IP アドレスを、他のシステムの設定値として使用することができます。Ansible に関連する変数をマジック変数と呼びます。

en: Ansible facts
ja: Ansible ファクト

en: Ansible facts are data related to your remote systems, including operating systems, IP addresses, attached filesystems, and more. You can access this data in the ``ansible_facts`` variable. By default, you can also access some Ansible facts as top-level variables with the ``ansible_`` prefix. You can disable this behavior using the :ref:`INJECT_FACTS_AS_VARS` setting. To see all available facts, add this task to a play::
ja: Ansible のファクトは、オペレーティングシステム、IP アドレス、添付のファイルシステムなど、リモートシステムに関連するデータです。このデータには、``ansible_facts`` という変数でアクセスできます。デフォルトでは、一部の Ansible ファクトは、``ansible_`` というプレフィックスを持つトップレベルの変数としてアクセスすることもできます。この動作は、:ref:`INJECT_FACTS_AS_VARS` の設定で無効にすることができます。利用可能なすべてのファクトを表示するには、このタスクをプレイに追加します。

en: To see the 'raw' information as gathered, run this command at the command line::
ja: 収集された「生」の情報を見るには、コマンドラインで次のコマンドを実行します。

en: Facts include a large amount of variable data, which may look like this:
ja: ファクトには大量の変数データが含まれており、それは次のようなものです。

en: You can reference the model of the first disk in the facts shown above in a template or playbook as::
ja: 上記のファクトの最初のディスクのモデルをテンプレートまたは Playbook で参照できます。

en: To reference the system hostname::
ja: システムのホスト名を参照するには、以下を実行します。

en: You can use facts in conditionals (see :ref:`playbooks_conditionals`) and also in templates. You can also use facts to create dynamic groups of hosts that match particular criteria, see the :ref:`group_by module <group_by_module>` documentation for details.
ja: ファクトは、条件式 (:ref:`playbooks_conditionals` を参照) やテンプレートでも使用できます。また、ファクトを使用して、特定の条件に一致するホストの動的なグループを作成することもできます。詳細は、:ref:`group_by モジュール <group_by_module>` のドキュメントを参照してください。

en: Package requirements for fact gathering
ja: ファクト収集のパッケージ要件

en: On some distros, you may see missing fact values or facts set to default values because the packages that support gathering those facts are not installed by default. You can install the necessary packages on your remote hosts using the OS package manager. Known dependencies include:
ja: 一部のディストリビューションでは、ファクトの収集をサポートするパッケージがデフォルトでインストールされていないため、ファクトの値が見つからなかったり、ファクトがデフォルト値に設定されたりすることがあります。OS のパッケージマネージャーを使用して、リモートホストに必要なパッケージをインストールすることができます。既知の依存関係には以下のものがあります。

en: Linux Network fact gathering -  Depends on  the ``ip`` binary, commonly included in the ``iproute2`` package.
ja: Linux ネットワークファクト収集 - 一般的に ``iproute2`` パッケージに含まれる ``ip`` バイナリーによって異なります。

en: Caching facts
ja: ファクトのキャッシュ

en: Like registered variables, facts are stored in memory by default. However, unlike registered variables, facts can be gathered independently and cached for repeated use. With cached facts, you can refer to facts from one system when configuring a second system, even if Ansible executes the current play on the second system first. For example::
ja: 登録された変数と同様に、ファクトはデフォルトでメモリーに保存されます。ただし、登録された変数とは異なり、ファクトは独立して収集し、繰り返し使用するためにキャッシュすることができます。キャッシュされたファクトを使用すると、Ansible が 2 つ目のシステムで現在のプレイを最初に実行した場合でも、1 つのシステムのファクトを参照して 2 つ目のシステムを設定することができます。以下に例を示します。

en: Caching is controlled by the cache plugins. By default, Ansible uses the memory cache plugin, which stores facts in memory for the duration of the current playbook run. To retain Ansible facts for repeated use, select a different cache plugin. See :ref:`cache_plugins` for details.
ja: キャッシュ処理は、キャッシュプラグインによって制御されます。デフォルトでは、Ansible はメモリーキャッシュプラグインを使用し、現在の Playbook の実行期間中、メモリーにファクトを保存します。Ansible のファクトを繰り返し使用するために保持するには、別のキャッシュプラグインを選択します。詳細は「:ref:`cache_plugins`」を参照してください。

en: Fact caching can improve performance. If you manage thousands of hosts, you can configure fact caching to run nightly, then manage configuration on a smaller set of servers periodically throughout the day. With cached facts, you have access to variables and information about all hosts even when you are only managing a small number of servers.
ja: ファクトキャッシュ処理はパフォーマンスを向上させます。何千台ものホストを管理している場合は、ファクトキャッシュ処理を毎晩実行するように設定し、小規模なサーバ群の設定を 1 日中定期的に管理することができます。キャッシュされたファクトがあれば、少数のサーバーしか管理していなくても、すべてのホストに関する変数および情報にアクセスすることができます。

en: Disabling facts
ja: ファクトの無効化

en: By default, Ansible gathers facts at the beginning of each play. If you do not need to gather facts (for example, if you know everything about your systems centrally), you can turn off fact gathering at the play level to improve scalability. Disabling facts may particularly improve performance in push mode with very large numbers of systems, or if you are using Ansible on experimental platforms. To disable fact gathering::
ja: デフォルトでは、Ansible は各プレイの開始時にファクトを収集します。ファクトを収集する必要がない場合 (たとえば、システムに関する情報をすべて一元的に把握している場合) は、プレイレベルでのファクト収集をオフにすることで、スケーラビリティーを向上させることができます。ファクトを無効にすると、非常に多数のシステムを使用するプッシュモードや、実験的なプラットフォームで Ansible を使用している場合に、特にパフォーマンスが向上することがあります。ファクトの収集を無効にするには、以下を行います。

en: Adding custom facts
ja: カスタムファクトの追加

en: The setup module in Ansible automatically discovers a standard set of facts about each host. If you want to add custom values to your facts, you can write a custom facts module, set temporary facts with a ``ansible.builtin.set_fact`` task, or provide permanent custom facts using the facts.d directory.
ja: Ansible のセットアップモジュールは、各ホストに関する標準的なファクトのセットを自動的に検出します。ファクトにカスタム値を追加したい場合は、カスタムファクトモジュールを記述したり、``ansible.builtin.set_fact`` タスクで一時的なファクトを設定したり、facts.d ディレクトリーを使用して恒久的なカスタムファクトを提供したりすることができます。

en: facts.d or local facts
ja: facts.d またはローカルファクト

en: You can add static custom facts by adding static files to facts.d, or add dynamic facts by adding executable scripts to facts.d. For example, you can add a list of all users on a host to your facts by creating and running a script in facts.d.
ja: 静的なカスタムファクトは、静的ファイルを facts.d に追加することで追加でき、動的なファクトは実行可能なスクリプトを facts.d に追加することで追加できます。たとえば、facts.d でスクリプトを作成して実行することにより、ホスト上のすべてのユーザーのリストをファクトに追加できます。

en: To use facts.d, create an ``/usr/local/etc/ansible/facts.d`` directory on the remote host or hosts. If you prefer a different directory, create it and specify it using the ``fact_path`` play keyword. Add files to the directory to supply your custom facts. All file names must end with ``.fact``. The files can be JSON, INI, or executable files returning JSON.
ja: facts.d を使用するには、リモートホストまたはホスト上に ``/usr/local/etc/ansible/facts.d`` ディレクトリーを作成します。別のディレクトリーを使用する場合は、そのディレクトリーを作成し、プレイキーワード ``fact_path`` を使用して指定します。このディレクトリーにファイルを追加して、カスタムファクトを提供します。すべてのファイル名は、``.fact`` で終わる必要があります。ファイルには、JSON、INI、または JSON を返す実行可能ファイルを使用できます。

en: To add static facts, simply add a file with the ``.fact`` extension. For example, create ``/usr/local/etc/ansible/facts.d/preferences.fact`` with this content::
ja: 静的ファクトを追加するには、``.fact`` 拡張子を持つファイルを追加するだけです。たとえば、以下の内容で ``/usr/local/etc/ansible/facts.d/preferences.fact`` を作成します。

en: Make sure the file is not executable as this will break the ``ansible.builtin.setup`` module.
ja: ``ansible.builtin.setup`` モジュールが壊れるため、このファイルが実行ファイルではないことを確認してください。

en: The next time fact gathering runs, your facts will include a hash variable fact named ``general`` with ``asdf`` and ``bar`` as members. To validate this, run the following::
ja: 次回、ファクト収集が実行されると、ファクトには、``asdf`` と``bar`` をメンバーとする ``general`` という名前のハッシュ変数ファクトが含まれるようになります。これを検証するには、次のように実行します。

en: And you will see your custom fact added::
ja: これにより、カスタムファクトが追加されているのが確認できます。

en: The ansible_local namespace separates custom facts created by facts.d from system facts or variables defined elsewhere in the playbook, so variables will not override each other. You can access this custom fact in a template or playbook as::
ja: ansible_local 名前空間は、facts.d で作成されたカスタムファクトと、システムファクトや Playbook 内の他の場所で定義された変数を分離し、変数が互いに上書きされないようにします。このカスタムファクトには、テンプレートや Playbook で次のようにアクセスできます。

en: The key part in the key=value pairs will be converted into lowercase inside the ansible_local variable. Using the example above, if the ini file contained ``XYZ=3`` in the ``[general]`` section, then you should expect to access it as: ``{{ ansible_local['preferences']['general']['xyz'] }}`` and not ``{{ ansible_local['preferences']['general']['XYZ'] }}``. This is because Ansible uses Python's `ConfigParser`_ which passes all option names through the `optionxform`_ method and this method's default implementation converts option names to lower case.
ja: 鍵と値のペアの鍵の部分は、ansible_local 変数内で小文字に変換されます。上記の例では、ini ファイルの ``[general]`` セクションに``XYZ=3`` が含まれていた場合は、``{{ ansible_local['preferences']['general']['XYZ'] }}`` ではなく、``{{ ansible_local['preferences']['general']['xyz'] }}`` としてアクセスすることになります。これは、Ansible が Python の`ConfigParser`_ を使用して、すべてのオプション名を `optionxform`_ メソッドに渡しており、このメソッドのデフォルトの実装では、オプション名が小文字に変換されるためです。

en: You can also use facts.d to execute a script on the remote host, generating dynamic custom facts to the ansible_local namespace. For example, you can generate a list of all users that exist on a remote host as a fact about that host. To generate dynamic custom facts using facts.d:
ja: facts.d を使用して、リモートホスト上でスクリプトを実行し、ansible_local 名前空間に動的なカスタムファクトを生成することもできます。たとえば、リモートホストに存在するすべてのユーザーのリストを、そのホストに関するファクトとして生成することができます。facts.d を使用して動的なカスタムファクトを生成するには、以下の手順に従います。

en: Write and test a script to generate the JSON data you want.
ja: スクリプトを作成してテストして、必要な JSON データを生成します。

en: Save the script in your facts.d directory.
ja: スクリプトを facts.d ディレクトリーに保存します。

en: Make sure your script has the ``.fact`` file extension.
ja: スクリプトに ``.fact`` ファイル拡張子があることを確認します。

en: Make sure your script is executable by the Ansible connection user.
ja: スクリプトが Ansible 接続ユーザーによって実行可能であることを確認します。

en: Gather facts to execute the script and add the JSON output to ansible_local.
ja: スクリプトを実行するファクトを収集し、JSON 出力を ansible_local に追加します。

en: By default, fact gathering runs once at the beginning of each play. If you create a custom fact using facts.d in a playbook, it will be available in the next play that gathers facts. If you want to use it in the same play where you created it, you must explicitly re-run the setup module. For example::
ja: デフォルトでは、ファクトの収集は各プレイの開始時に一度だけ実行します。Playbook で facts.d を使用してカスタムファクトを作成すると、ファクトを収集する次のプレイで使用できるようになります。作成したのと同じプレイで使用したい場合は、セットアップモジュールを明示的に再実行する必要があります。以下に例を示します。

en: If you use this pattern frequently, a custom facts module would be more efficient than facts.d.
ja: このパターンを頻繁に使用すると、カスタムファクトモジュールは facts.d よりも効率が上がります。

en: Information about Ansible: magic variables
ja: Ansible に関する情報: マジック変数

en: You can access information about Ansible operations, including the python version being used, the hosts and groups in inventory, and the directories for playbooks and roles, using "magic" variables. Like connection variables, magic variables are :ref:`special_variables`. Magic variable names are reserved - do not set variables with these names. The variable ``environment`` is also reserved.
ja: 使用している Python のバージョン、インベントリー内のホストやグループ、Playbook やロールのディレクトリーなど、Ansible の操作に関する情報は、「マジック」変数を使用してアクセスすることができます。接続変数と同様に、マジック変数は :ref:`special_variables` です。マジック変数の名前は予約済みです。これらの名前で変数を設定しないでください。変数 ``environment`` も予約済みです。

en: The most commonly used magic variables are ``hostvars``, ``groups``, ``group_names``, and ``inventory_hostname``. With ``hostvars``, you can access variables defined for any host in the play, at any point in a playbook. You can access Ansible facts using the ``hostvars`` variable too, but only after you have gathered (or cached) facts.
ja: 最も一般的に使用されるマジック変数は、``hostvars``、``groups``、``group_names``、および ``inventory_hostname`` です。``hostvars`` を使用すると、Playbook 内の任意の時点で、プレイ内の任意のホストに対して定義された変数にアクセスできます。``hostvars`` 変数を使用して Ansible のファクトにアクセスすることもできますが、ファクトを収集 (またはキャッシュ) した後でなければなりません。

en: If you want to configure your database server using the value of a 'fact' from another node, or the value of an inventory variable assigned to another node, you can use ``hostvars`` in a template or on an action line::
ja: 他のノードの「ファクト」の値や、他のノードに割り当てられたインベントリー変数の値を使用してデータベースサーバーを設定する場合は、テンプレートやアクション行で ``hostvars`` を使用することができます。

en: With ``groups``, a list of all the groups (and hosts) in the inventory, you can enumerate all hosts within a group. For example:
ja: ``groups`` では、インベントリー内のすべてのグループ (およびホスト) のリストで、グループ内のすべてのホストを列挙できます。以下に例を示します。

en: You can use ``groups`` and ``hostvars`` together to find all the IP addresses in a group.
ja: ``groups`` と ``hostvars`` を一緒に使用して、グループ内のすべての IP アドレスを探すことができます。

en: You can use this approach to point a frontend proxy server to all the hosts in your app servers group, to set up the correct firewall rules between servers, and so on. You must either cache facts or gather facts for those hosts before the task that fills out the template.
ja: この方法を使用して、フロントエンドプロキシーサーバーがアプリサーバーグループ内のすべてのホストを指すようにしたり、サーバー間に正しいファイアウォールルールを設定したりできます。テンプレートに入力するタスクの前に、ファクトをキャッシュするか、それらのホストのファクトを収集する必要があります。

en: With ``group_names``, a list (array) of all the groups the current host is in, you can create templated files that vary based on the group membership (or role) of the host:
ja: ``group_names`` では、現在のホストが置かれているすべてのグループのリスト (配列) は、ホストのグループメンバーシップ (またはロール) に基づいて異なるテンプレートファイルを作成できます。

en: You can use the magic variable ``inventory_hostname``, the name of the host as configured in your inventory, as an alternative to ``ansible_hostname`` when fact-gathering is disabled. If you have a long FQDN, you can use ``inventory_hostname_short``, which contains the part up to the first period, without the rest of the domain.
ja: ファクト収集が無効になっているときには、``ansible_hostname`` の代わりに、インベントリーで設定されたホストの名前であるマジック変数 ``inventory_hostname`` を使用できます。長い FQDN がある場合には、最初のピリオドまでの部分を含み、ドメインの残りの部分を含まない ``inventory_hostname_short`` を使用することができます。

en: Other useful magic variables refer to the current play or playbook. These vars may be useful for filling out templates with multiple hostnames or for injecting the list into the rules for a load balancer.
ja: その他の有用なマジック変数は、現在のプレイや Playbook を参照します。これらの変数は、複数のホスト名でテンプレートを埋めるときや、ロードバランサーのルールにリストを注入するときに便利です。

en: ``ansible_play_hosts`` is the list of all hosts still active in the current play.
ja: ``ansible_play_hosts`` は、現在のプレイでアクティブなままになっているすべてのホストの完全なリストです。

en: ``ansible_play_batch`` is a list of hostnames that are in scope for the current 'batch' of the play.
ja: ``ansible_play_batch`` は、現在のプレイの「バッチ」の範囲内にあるホスト名のリストです。

en: The batch size is defined by ``serial``, when not set it is equivalent to the whole play (making it the same as ``ansible_play_hosts``).
ja: バッチサイズは ``serial`` で定義されます。設定されていない場合は、プレイ全体に相当するようになります (``ansible_play_hosts`` と同じになります)。

en: ``ansible_playbook_python`` is the path to the python executable used to invoke the Ansible command line tool.
ja: ``ansible_playbook_python`` は、Ansible コマンドラインツールを起動するのに使用される Python 実行ファイルへのパスです。

en: ``inventory_dir`` is the pathname of the directory holding Ansible's inventory host file.
ja: ``inventory_dir`` は、Ansible のインベントリーホストファイルを保持するディレクトリーのパス名です。

en: ``inventory_file`` is the pathname and the filename pointing to the Ansible's inventory host file.
ja: ``inventory_file`` は、Ansible のインベントリーホストファイルを参照するパス名とファイル名です。

en: ``playbook_dir`` contains the playbook base directory.
ja: ``playbook_dir`` には Playbook のベースディレクトリーが含まれます。

en: ``role_path`` contains the current role's pathname and only works inside a role.
ja: ``role_path`` には現在のロールのパス名が含まれ、ロール内でのみ動作します。

en: ``ansible_check_mode`` is a boolean, set to ``True`` if you run Ansible with ``--check``.
ja: ``ansible_check_mode`` が ``--check`` で Ansible を実行する場合は ``True`` に設定します。

en: To adapt playbook behavior to different versions of Ansible, you can use the variable ``ansible_version``, which has the following structure::
ja: Playbook の動作をさまざまなバージョンの Ansible に適用するには、``ansible_version`` 変数を使用できます。この変数には、以下の構造があります。

en: Using vault in playbooks
ja: Playbook での Vault の使用

en: The documentation regarding Ansible Vault has moved. The new location is here: :ref:`vault`. Please update any links you may have made directly to this page.
ja: Ansible Vault に関するドキュメントが移動しました。新しい場所は「:ref:`vault`」です。このページに直接作成した可能性のあるリンクを更新してください。

en: Rejecting modules
ja: モジュールの拒否

en: If you want to avoid using certain modules, you can add them to a reject list to prevent Ansible from loading them. To reject plugins, create a yaml configuration file. The default location for this file is :file:`/usr/local/etc/ansible/plugin_filters.yml`. You can select a different path for the reject list using the :ref:`PLUGIN_FILTERS_CFG` setting in the ``defaults`` section of your ansible.cfg. Here is an example reject list:
ja: 特定のモジュールの使用を回避したい場合は、そのモジュールを拒否リストに追加して、Ansible がそのモジュールを読み込まないようにすることができます。プラグインを拒否するには、yaml 設定ファイルを作成します。このファイルのデフォルトの場所は :file:`/usr/local/etc/ansible/plugin_filters.yml` です。ansible.cfg の ``defaults`` セクションにある :ref:`PLUGIN_FILTERS_CFG` の設定を使用して、拒否リストの別のパスを選択できます。以下に拒否リストの例を示します。

en: The file contains two fields:
ja: このファイルには、2 つのフィールドが含まれています。

en: A file version so that you can update the format while keeping backwards compatibility in the future. The present version should be the string, ``"1.0"``
ja: 将来的に後方互換性を保ちながら形式を更新できるようにするファイルのバージョン。現在のバージョンは ``"1.0"`` 文字列とします。

en: A list of modules to reject. Ansible will not load any module in this list when it searches for a module to invoke for a task.
ja: 拒否するモジュールのリスト。Ansible は、モジュールを検索してタスクを呼び出すときに、このリストのモジュールを読み込みません。

en: The ``stat`` module is required for Ansible to run. Do not add this module to your reject list.
ja: Ansible を実行するには、``stat`` モジュールが必要です。このモジュールを拒否リストに追加しないでください。

en: Ansible Quickstart Guide
ja: Ansible クイックスタートガイド

en: We've recorded a short video that introduces Ansible.
ja: Ansible を紹介する短い動画を作成しました。

en: The `quickstart video <https://www.ansible.com/resources/videos/quick-start-video>`_ is about 13 minutes long and gives you a high level introduction to Ansible -- what it does and how to use it. We'll also tell you about other products in the Ansible ecosystem.
ja: `クイックスタートの動画 <https://www.ansible.com/resources/videos/quick-start-video>`_ は約 13 分で、Ansible が何をするのか、どのように使用するのかなど、Ansible を高レベルで紹介しています。また、Ansible のエコシステムにおける他の製品についてもご紹介します。

en: Enjoy, and be sure to visit the rest of the documentation to learn more.
ja: 動画をお楽しみください。より詳細な説明は、本ガイドをご覧ください。

en: A step by step introduction to Ansible
ja: Ansible の概要 (ステップバイステップ)

en: A downloadable guide for getting started with Ansible
ja: Ansible を使い始めるためのダウンロード可能なガイド

en: A guide for network engineers using Ansible for the first time
ja: はじめて Ansible を使用するネットワークエンジニアのためのガイド

en: Sample Ansible setup
ja: Ansible 設定の例

en: You have learned about playbooks, inventory, roles, and variables. This section pulls all those elements together, outlining a sample setup for automating a web service. You can find more example playbooks illustrating these patterns in our `ansible-examples repository <https://github.com/ansible/ansible-examples>`_.  (NOTE: These may not use all of the features in the latest release, but are still an excellent reference!).
ja: ここまで、Playbook、インベントリー、ロール、および変数について学んできました。このセクションでは、これらの要素をまとめて、Web サービスを自動化するためのセットアップのサンプルを紹介します。これらのパターンを示す Playbook の例は、`ansible-examples リポジトリー <https://github.com/ansible/ansible-examples>`_ を参照してください (注: 最新のリリースではすべての機能を使用していない場合がありますが、それでも優れた参考資料となります)。

en: The sample setup organizes playbooks, roles, inventory, and variables files by function, with tags at the play and task level for greater granularity and control. This is a powerful and flexible approach, but there are other ways to organize Ansible content. Your usage of Ansible should fit your needs, not ours, so feel free to modify this approach and organize your content as you see fit.
ja: サンプルの設定では、Playbook、ロール、インベントリー、変数ファイルを機能別に整理し、プレイやタスクのレベルでタグを付けて、より詳細にコントロールしています。これは強力で柔軟なアプローチですが、Ansible のコンテンツを整理する方法は他にもあります。Ansible の使用方法は、私たちのニーズでははなく、使用する人や組織のニーズに合わせる必要があります。したがって、このアプローチを自由に変更して、コンテンツを適切に整理してください。

en: Sample directory layout
ja: ディレクトリーレイアウトの例

en: This layout organizes most tasks in roles, with a single inventory file for each environment and a few playbooks in the top-level directory::
ja: このレイアウトでは、ほとんどのタスクがロールごとに整理されており、環境ごとに 1 つのインベントリーファイルを作成し、トップレベルのディレクトリーにいくつかの Playbook を置いています。

en: Alternative directory layout
ja: 代替ディレクトリーレイアウト

en: Alternatively you can put each inventory file with its ``group_vars``/``host_vars`` in a separate directory. This is particularly useful if your ``group_vars``/``host_vars`` don't have that much in common in different environments. The layout could look something like this::
ja: また、``group_vars``/``host_vars`` を含む各インベントリーファイルを別のディレクトリーに置くこともできます。これは、``group_vars``/``host_vars`` が異なる環境であまり共通していない場合に特に有効です。レイアウトは以下のようになります。

en: This layout gives you more flexibility for larger environments, as well as a total separation of inventory variables between different environments. However, this approach is harder to maintain, because there are more files. For more information on organizing group and host variables, see :ref:`splitting_out_vars`.
ja: このレイアウトにより、大規模な環境にも柔軟に対応することができ、異なる環境間でインベントリー変数を完全に分離することができます。しかし、この方法では、ファイル数が多くなるため、メンテナンスが難しくなります。グループ変数とホスト変数の整理の詳細は、「:ref:`splitting_out_vars`」を参照してください。

en: Sample group and host variables
ja: グループ変数およびホスト変数の例

en: These sample group and host variables files record the variable values that apply to each machine or group of machines. For instance, the data center in Atlanta has its own NTP servers, so when setting up ntp.conf, we should use them::
ja: これらのグループ変数とホスト変数のサンプルファイルには、各マシンやマシングループに適用される変数の値が記録されています。たとえば、アトランタのデータセンターには独自の NTP サーバーがあるため、ntp.conf を設定する際には、それらを使用する必要があります。

en: Similarly, the webservers have some configuration that does not apply to the database servers::
ja: 同様に、Web サーバーには、データベースサーバーには適用されない以下のような設定があります。

en: Default values, or values that are universally true, belong in a file called group_vars/all::
ja: デフォルト値または汎用的に true である値がある場合は、それらを group_vars/all というファイルに配置します。

en: If necessary, you can define specific hardware variance in systems in a host_vars file::
ja: 必要に応じて、システムの特定のハードウェアの差異を host_vars ファイルに定義することができます。

en: Again, if you are using :ref:`dynamic inventory <dynamic_inventory>`, Ansible creates many dynamic groups automatically.  So a tag like "class:webserver" would load in variables from the file "group_vars/ec2_tag_class_webserver" automatically.
ja: 繰り返しになりますが、:ref:`dynamic inventory <dynamic_inventory>` を使用している場合、Ansible は多くの動的グループを自動的に作成します。つまり、「class:webserver」のようなタグは、「group_vars/ec2_tag_class_webserver」ファイルから変数を自動的に読み込むことになります。

en: Sample playbooks organized by function
ja: 関数別に整理された Playbook のサンプル

en: With this setup, a single playbook can define all the infrastructure. The site.yml playbook imports two other playbooks, one for the webservers and one for the database servers::
ja: この設定では、1 つの Playbook ですべてのインフラストラクチャーを定義することができます。Playbook site.yml は、Web サーバー用とデータベースサーバー用の 2 つの Playbook をインポートしています。

en: The webservers.yml file, also at the top level, maps the configuration of the webservers group to the roles related to the webservers group::
ja: 同じく最上位にある webservers.yml ファイルは、webservers グループの設定を、webservers グループに関連するロールにマッピングします。

en: With this setup, you can configure your whole infrastructure by "running" site.yml, or run a subset by running webservers.yml.  This is analogous to the Ansible "--limit" parameter but a little more explicit::
ja: この設定により、site.yml を実行してインフラストラクチャー全体を設定したり、webservers.yml を実行してサブセットを設定したりすることができます。これは、Ansible の「--limit」パラメーターに似ていますが、もう少し明確になっています。

en: Sample task and handler files in a function-based role
ja: 関数ベースのロール内のタスクおよびハンドラーファイルのサンプル

en: Ansible loads any file called ``main.yml`` in a role sub-directory. This sample ``tasks/main.yml`` file is simple - it sets up NTP, but it could do more if we wanted::
ja: Ansible は、ロールのサブディレクトリーにある ``main.yml`` ファイルを読み込みます。このサンプルの ``tasks/main.yml`` ファイルは、NTP を設定するというシンプルなものですが、必要に応じてもっと多くのことができます。

en: Here is an example handlers file.  As a review, handlers are only fired when certain tasks report changes, and are run at the end of each play::
ja: ハンドラーファイルの例を紹介します。レビューとして、ハンドラーは特定のタスクが変更を報告したときにのみ起動し、各プレイの最後に実行します。

en: See :ref:`playbooks_reuse_roles` for more information.
ja: 詳細は、「:ref:`playbooks_reuse_roles`」を参照してください。

en: What the sample setup enables
ja: 設定例の有効化

en: The basic organizational structure described above enables a lot of different automation options. To reconfigure your entire infrastructure::
ja: 上記の基本的な組織構造により、多くの異なる自動化オプションが可能になります。インフラ全体を再構成するには、以下のようになります。

en: To reconfigure NTP on everything::
ja: 全面的に NTP を再設定するには、以下を実行します。

en: To reconfigure only the webservers::
ja: Web サーバーのみを再設定するには、以下を実行します。

en: To reconfigure only the webservers in Boston::
ja: Boston で Web サーバーのみを再設定するには、以下を実行します。

en: To reconfigure only the first 10 webservers in Boston, and then the next 10::
ja: Boston で最初の 10 台のウェブサーバーだけを再設定し、次の10台は、以下のようにします。

en: The sample setup also supports basic ad hoc commands::
ja: 設定例では、基本的なアドホックコマンドもサポートします。

en: To discover what tasks would run or what hostnames would be affected by a particular Ansible command::
ja: 実行するタスクまたは特定の Ansible コマンドの影響を受けるホスト名を検出するには、以下を実行します。

en: Organizing for deployment or configuration
ja: デプロイメントまたは設定の整理

en: The sample setup models a typical configuration topology.  When doing multi-tier deployments, there are going to be some additional playbooks that hop between tiers to roll out an application. In this case, 'site.yml' may be augmented by playbooks like 'deploy_exampledotcom.yml' but the general concepts still apply. Ansible allows you to deploy and configure using the same tool, so you would likely reuse groups and keep the OS configuration in separate playbooks or roles from the app deployment.
ja: このサンプルでは、典型的な構成トポロジーをモデル化しています。複数階層のデプロイメントを行う場合は、アプリケーションを展開するために階層間を行き来する Playbook が追加されることがあります。この場合、「site.yml」には「deploy_exampledotcom.yml」などの Playbook が追加されますが、一般的な概念は変わりません。Ansible では、デプロイと設定を同じツールで行うことができるため、グループを再利用したり、OS の設定をアプリのデプロイとは別の Playbook やロールにまとめたりすることが考えられます。

en: Consider "playbooks" as a sports metaphor -- you can have one set of plays to use against all your infrastructure and situational plays that you use at different times and for different purposes.
ja: 「Playbook」をスポーツに例えて考えてみましょう。すべてのインフラストラクチャーに対して使用する 1 セットのプレイと、時と場合に応じて使用する状況に応じたプレイがあります。

en: Using local Ansible modules
ja: ローカル Ansible モジュールの使用

en: If a playbook has a :file:`./library` directory relative to its YAML file, this directory can be used to add Ansible modules that will automatically be in the Ansible module path.  This is a great way to keep modules that go with a playbook together.  This is shown in the directory structure example at the start of this section.
ja: Playbook が YAML ファイルに相対する :file:`./library` ディレクトリーを持っている場合は、このディレクトリーを使用して、自動的に Ansible モジュールパスに含まれる Ansible モジュールを追加することができます。これは、Playbook に付随するモジュールをまとめておくのに最適な方法です。これは、このセクションの最初にあるディレクトリー構造の例で示されています。

en: Encrypting content with Ansible Vault
ja: Ansible Vault を使用したコンテンツの暗号化

en: Ansible Vault encrypts variables and files so you can protect sensitive content such as passwords or keys rather than leaving it visible as plaintext in playbooks or roles. To use Ansible Vault you need one or more passwords to encrypt and decrypt content. If you store your vault passwords in a third-party tool such as a secret manager, you need a script to access them. Use the passwords with the :ref:`ansible-vault` command-line tool to create and view encrypted variables, create encrypted files, encrypt existing files, or edit, re-key, or decrypt files. You can then place encrypted content under source control and share it more safely.
ja: Ansible Vault は変数やファイルを暗号化するため、パスワードや鍵などの機密コンテンツを Playbook やロールの中で平文のまま放置することなく保護することができます。Ansible Vault を使用するには、コンテンツを暗号化および復号化するための 1 つ以上のパスワードが必要です。シークレットマネージャーなどのサードパーティーツールに Vault のパスワードを保存している場合は、そのパスワードにアクセスするためのスクリプトが必要です。:ref:`ansible-vault` コマンドラインツールでパスワードを使用して、暗号化された変数の作成と表示、暗号化されたファイルの作成、既存のファイルの暗号化、またはファイルの編集、鍵の再設定、復号を行います。また、暗号化されたコンテンツをソースコントロール下に置き、より安全に共有することができます。

en: Encryption with Ansible Vault ONLY protects 'data at rest'.  Once the content is decrypted ('data in use'), play and plugin authors are responsible for avoiding any secret disclosure, see :ref:`no_log <keep_secret_data>` for details on hiding output and :ref:`vault_securing_editor` for security considerations on editors you use with Ansible Vault.
ja: Ansible Vault による暗号化は、「静止状態のデータ」のみを保護します。コンテンツが復号化された後 (「使用中のデータ」)、プレイやプラグインの作者は、秘密の漏洩を回避する責任があります。出力の隠蔽に関する詳細は「:ref:`no_log <keep_secret_data>`」を、Ansible Vault で使用するエディターのセキュリティーに関する考慮点は「:ref:`vault_securing_editor`」を参照してください。

en: You can use encrypted variables and files in ad hoc commands and playbooks by supplying the passwords you used to encrypt them. You can modify your ``ansible.cfg`` file to specify the location of a password file or to always prompt for the password.
ja: 暗号化された変数やファイルは、暗号化に使用したパスワードを入力することで、アドホックコマンドや Playbook で使用することができます。``ansible.cfg`` ファイルを変更して、パスワードファイルの場所を指定したり、常にパスワードの入力を促すようにすることができます。

en: Managing vault passwords
ja: Vault パスワードの管理

en: Managing your encrypted content is easier if you develop a strategy for managing your vault passwords. A vault password can be any string you choose. There is no special command to create a vault password. However, you need to keep track of your vault passwords. Each time you encrypt a variable or file with Ansible Vault, you must provide a password. When you use an encrypted variable or file in a command or playbook, you must provide the same password that was used to encrypt it. To develop a strategy for managing vault passwords, start with two questions:
ja: 暗号化されたコンテンツを管理するには、Vault のパスワードを管理するためのストラテジーを立てるとよいでしょう。Vault パスワードは任意の文字列です。Vault パスワードを作成するための特別なコマンドはありません。しかし、Vault 保管庫パスワードを管理する必要があります。Ansible Vault で変数やファイルを暗号化する際は、毎回パスワードを入力する必要があります。暗号化された変数やファイルをコマンドや Playbook で使用する際には、暗号化に使用したのと同じパスワードを提供する必要があります。Vault のパスワードを管理するためのストラテジーを立てるには、次の 2 つの質問から始めます。

en: Do you want to encrypt all your content with the same password, or use different passwords for different needs?
ja: 同じパスワードですべてのコンテンツを暗号化する必要があるか、異なるニーズに合わせて異なるパスワードを使用しますか？

en: Where do you want to store your password or passwords?
ja: パスワードをどこに保存しますか。

en: Choosing between a single password and multiple passwords
ja: 1 つのパスワードと複数のパスワードの選択

en: If you have a small team or few sensitive values, you can use a single password for everything you encrypt with Ansible Vault. Store your vault password securely in a file or a secret manager as described below.
ja: 少人数のチームや機密性の高い値が少ない場合は、Ansible Vault で暗号化するすべてのものに 1 つのパスワードを使用することができます。Vault のパスワードは、後述するようにファイルやシークレットマネージャーに安全に保管してください。

en: If you have a larger team or many sensitive values, you can use multiple passwords. For example, you can use different passwords for different users or different levels of access. Depending on your needs, you might want a different password for each encrypted file, for each directory, or for each environment. For example, you might have a playbook that includes two vars files, one for the dev environment and one for the production environment, encrypted with two different passwords. When you run the playbook, select the correct vault password for the environment you are targeting, using a vault ID.
ja: チームの規模が大きかったり、機密性の高い値が多い場合は、複数のパスワードを使用することができます。たとえば、ユーザーやアクセスレベルごとに異なるパスワードを使用することができます。必要に応じて、暗号化されたファイルごと、ディレクトリーごと、あるいは環境ごとに異なるパスワードが必要になる場合があります。たとえば、開発環境用と実稼働環境用の 2 つの vars ファイルを含む Playbook を作成し、2 つの異なるパスワードで暗号化する場合などです。Playbook を実行する際には、Vault ID を使用して、対象となる環境に適した Vault パスワードを選択します。

en: Managing multiple passwords with vault IDs
ja: vault ID を使用した複数パスワードの管理

en: If you use multiple vault passwords, you can differentiate one password from another with vault IDs. You use the vault ID in three ways:
ja: 複数の vault パスワードを使用する場合は、vault ID から別のパスワードを区別することができます。以下の 3 つの方法で vault ID を使用します。

en: Pass it with :option:`--vault-id <ansible-playbook --vault-id>` to the :ref:`ansible-vault` command when you create encrypted content
ja: 暗号化されたコンテンツの作成時に、:option:`--vault-id <ansible-playbook --vault-id>` を :ref:`ansible-vault` コマンドに渡します。

en: Include it wherever you store the password for that vault ID (see :ref:`storing_vault_passwords`)
ja: その vault ID のパスワードを保存する場所を追加します (:ref:`storing_vault_passwords` を参照)。

en: Pass it with :option:`--vault-id <ansible-playbook --vault-id>` to the :ref:`ansible-playbook` command when you run a playbook that uses content you encrypted with that vault ID
ja: vault ID で暗号化されたコンテンツを使用する Playbook を実行する際に、これを :option:`--vault-id <ansible-playbook --vault-id>` で :ref:`ansible-playbook` コマンドに渡します。

en: When you pass a vault ID as an option to the :ref:`ansible-vault` command, you add a label (a hint or nickname) to the encrypted content. This label documents which password you used to encrypt it. The encrypted variable or file includes the vault ID label in plain text in the header. The vault ID is the last element before the encrypted content. For example::
ja: :ref:`ansible-vault` コマンドのオプションとして Vault ID を渡すと、暗号化されたコンテンツにラベル (ヒントやニックネーム) が追加されます。このラベルは、どのパスワードを使用して暗号化したかを記録します。暗号化された変数やファイルは、ヘッダーに平文で Vault ID ラベルを含みます。Vault ID は暗号化されたコンテンツの前の最後の要素です。以下に例を示します。

en: In addition to the label, you must provide a source for the related password. The source can be a prompt, a file, or a script, depending on how you are storing your vault passwords. The pattern looks like this:
ja: ラベルに加えて、関連するパスワードのソースを提供する必要があります。ソースは、Vault パスワードをどのように保存するかによって、プロンプト、ファイル、またはスクリプトになります。パターンは次のようになります。

en: If your playbook uses multiple encrypted variables or files that you encrypted with different passwords, you must pass the vault IDs when you run that playbook. You can use :option:`--vault-id <ansible-playbook --vault-id>` by itself, with :option:`--vault-password-file <ansible-playbook --vault-password-file>`, or with :option:`--ask-vault-pass <ansible-playbook --ask-vault-pass>`. The pattern is the same as when you create encrypted content: include the label and the source for the matching password.
ja: Playbook が複数の暗号化された変数や、異なるパスワードで暗号化したファイルを使用する場合は、その Playbook を実行する際に Vault ID を渡す必要があります。:option:`--vault-id <ansible-playbook --vault-id>` を単独で、もしくは :option:`--vault-password-file <ansible-playbook --vault-password-file>` または :option:`--ask-vault-pass <ansible-playbook --ask-vault-pass>` と一緒に使用することができます。パターンは、暗号化されたコンテンツを作成するときと同じで、一致するパスワードのラベルとソースを含めます。

en: See below for examples of encrypting content with vault IDs and using content encrypted with vault IDs. The :option:`--vault-id <ansible-playbook --vault-id>` option works with any Ansible command that interacts with vaults, including :ref:`ansible-vault`, :ref:`ansible-playbook`, and so on.
ja: Vault ID でコンテンツを暗号化する例と、Vault ID で暗号化されたコンテンツを使用する例については、以下を参照してください。:option:`--vault-id <ansible-playbook --vault-id>` オプションは、:ref:`ansible-vault`、:ref:`ansible-playbook` など、Vault と相互作用するすべての Ansible コマンドで動作します。

en: Limitations of vault IDs
ja: vault ID の制限

en: Ansible does not enforce using the same password every time you use a particular vault ID label. You can encrypt different variables or files with the same vault ID label but different passwords. This usually happens when you type the password at a prompt and make a mistake. It is possible to use different passwords with the same vault ID label on purpose. For example, you could use each label as a reference to a class of passwords, rather than a single password. In this scenario, you must always know which specific password or file to use in context. However, you are more likely to encrypt two files with the same vault ID label and different passwords by mistake. If you encrypt two files with the same label but different passwords by accident, you can :ref:`rekey <rekeying_files>` one file to fix the issue.
ja: Ansible は、特定の Vault ID ラベルを使用するたびに同じパスワードを使用することを強制しません。異なる変数やファイルを、同じ Vault ID ラベルで異なるパスワードで暗号化することができます。これは通常、プロンプトでパスワードを入力して間違えた場合に起こります。意図的に、同じ Vault ID ラベルで異なるパスワードを使用することは可能です。たとえば、各ラベルを、単一のパスワードではなく、パスワードのクラスへの参照として使用することができます。このシナリオでは、どの特定のパスワードまたはファイルを使用するかを常にコンテキストで知っておく必要があります。しかし、誤って同じ Vault ID ラベルと異なるパスワードを持つ 2 つのファイルを暗号化してしまう可能性が高くなります。誤って同じラベルで異なるパスワードの 2 つのファイルを暗号化してしまった場合は、1つのファイルで :ref:`rekey <rekeying_files>` を行って問題を解決できます。

en: Enforcing vault ID matching
ja: Vault ID 一致の強制

en: By default the vault ID label is only a hint to remind you which password you used to encrypt a variable or file. Ansible does not check that the vault ID in the header of the encrypted content matches the vault ID you provide when you use the content. Ansible decrypts all files and variables called by your command or playbook that are encrypted with the password you provide. To check the encrypted content and decrypt it only when the vault ID it contains matches the one you provide with ``--vault-id``, set the config option :ref:`DEFAULT_VAULT_ID_MATCH`. When you set :ref:`DEFAULT_VAULT_ID_MATCH`, each password is only used to decrypt data that was encrypted with the same label. This is efficient, predictable, and can reduce errors when different values are encrypted with different passwords.
ja: デフォルトでは、Vault ID ラベルは、変数やファイルの暗号化にどのパスワードを使用したかを思い出させるためのヒントに過ぎません。Ansible は、暗号化されたコンテンツのヘッダーにある vault ID が、コンテンツの使用時に提供した Vault ID と一致するかどうかはチェックしません。Ansible は、提供したパスワードで暗号化されたコマンドまたは Playbook によって呼び出されたすべてのファイルおよび変数を復号します。暗号化されたコンテンツをチェックし、コンテンツに含まれる Vault ID が ``--vault-id`` で提供したものと一致した場合にのみ暗号化を解除するには、設定オプション :ref:`DEFAULT_VAULT_ID_MATCH` を設定します。:ref:`DEFAULT_VAULT_ID_MATCH` を設定すると、各パスワードは同じラベルで暗号化されたデータの復号にのみ使用されます。これは効率的で予測可能であり、異なる値が異なるパスワードで暗号化された場合のエラーを減らすことができます。

en: Even with the :ref:`DEFAULT_VAULT_ID_MATCH` setting enabled, Ansible does not enforce using the same password every time you use a particular vault ID label.
ja: :ref:`DEFAULT_VAULT_ID_MATCH` の設定が有効になっている場合でも、特定の vault ID ラベルを使用するたびに、Ansible は同じパスワードの使用を強制しません。

en: Storing and accessing vault passwords
ja: Vault パスワードの保存およびアクセス

en: You can memorize your vault password, or manually copy vault passwords from any source and paste them at a command-line prompt, but most users store them securely and access them as needed from within Ansible. You have two options for storing vault passwords that work from within Ansible: in files, or in a third-party tool such as the system keyring or a secret manager. If you store your passwords in a third-party tool, you need a vault password client script to retrieve them from within Ansible.
ja: Valut パスワードを記憶したり、Valut パスワードを任意のソースから手動でコピーしてコマンドラインプロンプトに貼り付けたりすることもできますが、ほとんどのユーザーは安全に保管し、必要に応じて Ansible 内からアクセスします。Ansible 内で機能する Valut パスワードの保管方法には、ファイルに保管する方法と、システムキーリングやシークレットマネージャーなどのサードパーティーツールに保管する方法があります。サードパーティーのツールにパスワードを保存する場合、Ansible 内からパスワードを取得するには、Vault パスワードクライアントスクリプトが必要です。

en: Storing passwords in files
ja: パスワードのファイルへの保存

en: To store a vault password in a file, enter the password as a string on a single line in the file. Make sure the permissions on the file are appropriate. Do not add password files to source control.
ja: Vault のパスワードをファイルに保存するには、ファイルの 1 行にパスワードを文字列で入力します。ファイルのパーミッションが適切であることを確認してください。パスワードファイルをソースコントロールに追加しないでください。

en: Storing passwords in third-party tools with vault password client scripts
ja: Vault パスワードクライアントスクリプトを使用したサードパーティーツールへのパスワードの保存

en: You can store your vault passwords on the system keyring, in a database, or in a secret manager and retrieve them from within Ansible using a vault password client script. Enter the password as a string on a single line. If your password has a vault ID, store it in a way that works with your password storage tool.
ja: Valut パスワードは、システムキーリング、データベース、またはシークレットマネージャーに保存し、Valut パスワードクライアントスクリプトを使用して Ansible 内から取り出すことができます。パスワードは 1 行の文字列として入力します。パスワードに Vault ID がある場合は、パスワード保存ツールと連携する方法で保存します。

en: To create a vault password client script:
ja: Vault パスワードクライアントスクリプトを作成するには、以下のようにします。

en: Create a file with a name ending in either ``-client`` or ``-client.EXTENSION``
ja: 名前が ``-client`` または ``-client.EXTENSION`` で終わるファイルを作成します。

en: Make the file executable
ja: ファイルを実行可能な状態にする

en: Within the script itself:
ja: スクリプト自体:

en: Print the passwords to standard output
ja: 標準出力にパスワードを出力します

en: Accept a ``--vault-id`` option
ja: ``--vault-id`` オプションを受け入れる

en: If the script prompts for data (for example, a database password), send the prompts to standard error
ja: スクリプトがデータを要求する場合 (例; データベースパスワード) には、プロンプトを標準エラーに送信します。

en: When you run a playbook that uses vault passwords stored in a third-party tool, specify the script as the source within the ``--vault-id`` flag. For example:
ja: サードパーティーのツールに保存されている Vault パスワードを使用する Playbook を実行する場合は、``--vault-id`` フラグ内でスクリプトをソースとして指定します。以下を例に示します。

en: Ansible executes the client script with a ``--vault-id`` option so the script knows which vault ID label you specified. For example a script loading passwords from a secret manager can use the vault ID label to pick either the 'dev' or 'prod' password. The example command above results in the following execution of the client script:
ja: Ansible はクライアントスクリプトを ``--vault-id`` オプション付きで実行するため、スクリプトは指定された Vault ID ラベルを知ることができます。たとえば、シークレットマネージャーからパスワードを読み込むスクリプトは、Vault ID ラベルを使用して、「dev」または「prod」のいずれかのパスワードを選択できます。上記のコマンドの例では、クライアントスクリプトの実行結果は次のようになります。

en: For an example of a client script that loads passwords from the system keyring, see :file:`contrib/vault/vault-keyring-client.py`.
ja: システムキーリングからパスワードを読み込むクライアントスクリプトの例は、:file:`contrib/vault/vault-keyring-client.py` を参照してください。

en: Once you have a strategy for managing and storing vault passwords, you can start encrypting content. You can encrypt two types of content with Ansible Vault: variables and files. Encrypted content always includes the ``!vault`` tag, which tells Ansible and YAML that the content needs to be decrypted, and a ``|`` character, which allows multi-line strings. Encrypted content created with ``--vault-id`` also contains the vault ID label. For more details about the encryption process and the format of content encrypted with Ansible Vault, see :ref:`vault_format`. This table shows the main differences between encrypted variables and encrypted files:
ja: Vault のパスワードを管理および保管するためのストラテジーができたら、コンテンツの暗号化を開始しましょう。Ansible Vault では、変数とファイルの 2 種類のコンテンツを暗号化することができます。暗号化されたコンテンツには、必ず ``!vault`` タグが含まれています。これは、コンテンツの復号が必要であることを Ansible と YAML に伝えるもので、複数行の文字列を可能にする ``|`` 文字も含まれています。``--vault-id`` で作成された暗号化コンテンツには、Vault ID ラベルも含まれます。Ansible Vault で暗号化されたコンテンツの暗号化プロセスと形式の詳細は、「:ref:`vault_format`」を参照してください。この表は、暗号化された変数と暗号化されたファイルの主な違いを示しています。

en: Encrypted variables
ja: 暗号化された変数

en: Encrypted files
ja: 暗号化されたファイル

en: How much is encrypted?
ja: どのくらい暗号化されているのか。

en: Variables within a plaintext file
ja: 平文ファイル内の変数

en: The entire file
ja: ファイル全体

en: When is it decrypted?
ja: 復号するタイミング

en: On demand, only when needed
ja: オンデマンドで (必要な場合にのみ)

en: Whenever loaded or referenced [#f1]_
ja: 読み込みまたは参照する場合 [#f1]_

en: What can be encrypted?
ja: 暗号化できるもの。

en: Only variables
ja: 変数のみ

en: Any structured data file
ja: 構造化データファイル

en: Ansible cannot know if it needs content from an encrypted file unless it decrypts the file, so it decrypts all encrypted files referenced in your playbooks and roles.
ja: Ansible は、ファイルを復号しない限り、暗号化されたファイルからコンテンツを必要とするかどうかを認識できないため、Playbook およびロールで参照される暗号化されたファイルをすべて復号します。

en: Encrypting individual variables with Ansible Vault
ja: Ansible Vault による個々の変数の暗号化

en: You can encrypt single values inside a YAML file using the :ref:`ansible-vault encrypt_string <ansible_vault_encrypt_string>` command. For one way to keep your vaulted variables safely visible, see :ref:`tip_for_variables_and_vaults`.
ja: :ref:`ansible-vault encrypt_string <ansible_vault_encrypt_string>` コマンドを使用して、YAML ファイル内で 1 つの値を暗号化することができます。vault を使用した変数を安全に表示できる方法は、「:ref:`tip_for_variables_and_vaults`」を参照してください。

en: Advantages and disadvantages of encrypting variables
ja: 変数を暗号化することの利点および欠点

en: With variable-level encryption, your files are still easily legible. You can mix plaintext and encrypted variables, even inline in a play or role. However, password rotation is not as simple as with file-level encryption. You cannot :ref:`rekey <rekeying_files>` encrypted variables. Also, variable-level encryption only works on variables. If you want to encrypt tasks or other content, you must encrypt the entire file.
ja: 変数レベルの暗号化では、ファイルを簡単に読み取ることができます。平文の変数と暗号化された変数を混在させることができ、プレイやロールの中でインラインでも使用できます。しかし、パスワードのローテーションはファイルレベルの暗号化のように簡単ではありません。で暗号化された変数に :ref:`鍵の再設定 <rekeying_files>` は使用できません。また、変数レベルの暗号化は変数に対してのみ機能します。タスクやその他のコンテンツを暗号化したい場合は、ファイル全体を暗号化する必要があります。

en: Creating encrypted variables
ja: 暗号化されたファイルの作成

en: The :ref:`ansible-vault encrypt_string <ansible_vault_encrypt_string>` command encrypts and formats any string you type (or copy or generate) into a format that can be included in a playbook, role, or variables file. To create a basic encrypted variable, pass three options to the :ref:`ansible-vault encrypt_string <ansible_vault_encrypt_string>` command:
ja: :ref:`ansible-vault encrypt_string <ansible_vault_encrypt_string>` コマンドは、入力 (もしくはコピーまたは生成) した文字列を暗号化して、Playbook、ロール、変数ファイルに含めることができる形式にします。基本的な暗号化変数を作成するには、:ref:`ansible-vault encrypt_string <ansible_vault_encrypt_string>` コマンドに 3 つのオプションを渡します。

en: a source for the vault password (prompt, file, or script, with or without a vault ID)
ja: vault パスワードのソース (プロンプト、ファイル、またはスクリプト、vault ID ありまたはなし)

en: the string to encrypt
ja: 暗号化する文字列

en: the string name (the name of the variable)
ja: 文字列名 (変数の名前)

en: The pattern looks like this:
ja: パターンは以下のようになります。

en: For example, to encrypt the string 'foobar' using the only password stored in 'a_password_file' and name the variable 'the_secret':
ja: たとえば、「a_password_file」に保存されたパスワードのみを使用して文字列を「foobar」を暗号化する際に、変数「the_secret」に名前を付けます。

en: The command above creates this content::
ja: 上記のコマンドにより、以下のような内容が作成されます。

en: To encrypt the string 'foooodev', add the vault ID label 'dev' with the 'dev' vault password stored in 'a_password_file', and call the encrypted variable 'the_dev_secret':
ja: 文字列「foooodev」を暗号化するには、Vault ID ラベル「dev」に「a_password_file」に格納されている「dev」の Vault パスワードを追加し、暗号化された変数「the_dev_secret」を呼び出します。

en: To encrypt the string 'letmein' read from stdin, add the vault ID 'dev' using the 'dev' vault password stored in `a_password_file`, and name the variable 'db_password':
ja: 標準入力から読み込んだ文字列「letmein」を暗号化するために、`a_password_file` に保存されている「dev」の Vault のパスワードを使用してVault ID「dev」を追加し、変数に「db_password」という名前を付けます。

en: Typing secret content directly at the command line (without a prompt) leaves the secret string in your shell history. Do not do this outside of testing.
ja: 秘密の内容をコマンドラインで直接入力すると (プロンプトなし)、シェルの履歴に秘密の文字列が残ります。テスト時以外はこのようなことをしないでください。

en: The command above creates this output::
ja: 上記のコマンドにより、以下が出力されます。

en: To be prompted for a string to encrypt, encrypt it with the 'dev' vault password from 'a_password_file', name the variable 'new_user_password' and give it the vault ID label 'dev':
ja: 暗号化する文字列の入力を求められるので、「a_password_file」の「dev」の Vault パスワードで暗号化し、変数名を「new_user_password」とし、Vault ID ラベル「dev」を付与します。

en: The command above triggers this prompt:
ja: 上記のコマンドにより、以下のプロンプトがトリガーされます。

en: Type the string to encrypt (for example, 'hunter2'), hit ctrl-d, and wait.
ja: 暗号化する文字列 (「hunter2」など)、ctrl-d を押してお待ちください。

en: Do not press ``Enter`` after supplying the string to encrypt. That will add a newline to the encrypted value.
ja: 暗号化する文字列を指定した後に ``Enter`` を押さないでください。暗号化された値に改行を追加します。

en: The sequence above creates this output::
ja: 上記のシーケンスにより、以下のような出力が作成されます。

en: You can add the output from any of the examples above to any playbook, variables file, or role for future use. Encrypted variables are larger than plain-text variables, but they protect your sensitive content while leaving the rest of the playbook, variables file, or role in plain text so you can easily read it.
ja: 上記の例の出力を、将来使用するために、任意の Playbook、変数ファイル、またはロールに追加することができます。暗号化された変数は、平文の変数よりもサイズが大きくなりますが、機密性の高いコンテンツを保護する一方で、Playbook、変数ファイル、またはロールの残りの部分は平文のままなので、簡単に読み取ることができます。

en: Viewing encrypted variables
ja: 暗号化された変数の表示

en: You can view the original value of an encrypted variable using the debug module. You must pass the password that was used to encrypt the variable. For example, if you stored the variable created by the last example above in a file called 'vars.yml', you could view the unencrypted value of that variable like this:
ja: 暗号化された変数の元の値は、デバッグモジュールを使用して見ることができます。その際には、変数の暗号化に使用したパスワードを渡す必要があります。たとえば、上記の最後の例で作成した変数を「vars.yml」というファイルに保存した場合、その変数の暗号化されていない値を見るには次のようにします。

en: Encrypting files with Ansible Vault
ja: Ansible Vault によるファイルの暗号化

en: Ansible Vault can encrypt any structured data file used by Ansible, including:
ja: Ansible Vault は、Ansible が使用するあらゆる構造化データファイルを暗号化することができます。以下に例を示します。

en: group variables files from inventory
ja: インベントリーからのグループ変数ファイル

en: host variables files from inventory
ja: インベントリーからのホスト変数ファイル

en: variables files passed to ansible-playbook with ``-e @file.yml`` or ``-e @file.json``
ja: ``-e @file.yml`` または ``-e @file.json`` で ansible-playbook に渡される変数ファイル

en: variables files loaded by ``include_vars`` or ``vars_files``
ja: ``include_vars`` または ``vars_files`` により読み込まれた変数ファイル

en: variables files in roles
ja: ロールの変数ファイル

en: defaults files in roles
ja: ロール内のデフォルトファイル

en: tasks files
ja: tasks ファイル

en: handlers files
ja: ハンドラーファイル

en: binary files or other arbitrary files
ja: バイナリーファイルまたはその他の任意のファイル

en: The full file is encrypted in the vault.
ja: 完全なファイルは vault で暗号化されます。

en: Ansible Vault uses an editor to create or modify encrypted files. See :ref:`vault_securing_editor` for some guidance on securing the editor.
ja: Ansible Vault はエディターを使用して暗号化されたファイルの作成または変更します。エディターのセキュリティー保護に関するいくつかのガイダンスは、「:ref:`vault_securing_editor`」を参照してください。

en: Advantages and disadvantages of encrypting files
ja: ファイルを暗号化することの利点および欠点

en: File-level encryption is easy to use. Password rotation for encrypted files is straightforward with the :ref:`rekey <rekeying_files>` command. Encrypting files can hide not only sensitive values, but the names of the variables you use. However, with file-level encryption the contents of files are no longer easy to access and read. This may be a problem with encrypted tasks files. When encrypting a variables file, see :ref:`tip_for_variables_and_vaults` for one way to keep references to these variables in a non-encrypted file. Ansible always decrypts the entire encrypted file when it is when loaded or referenced, because Ansible cannot know if it needs the content unless it decrypts it.
ja: ファイルレベルの暗号化は簡単に使用できます。暗号化されたファイルのパスワードローテーションは、:ref:`rekey <rekeying_files>` コマンドで簡単に行うことができます。ファイルを暗号化すると、センシティブな値だけでなく、使用する変数の名前も隠すことができます。しかし、ファイルレベルの暗号化では、ファイルの内容に簡単にアクセスして読むことができなくなります。これは暗号化されたタスクファイルでは問題になるかもしれません。変数ファイルを暗号化する場合は、これらの変数への参照を暗号化されていないファイルに保持する 1 つの方法については、「:ref:`tip_for_variables_and_vaults`」を参照してください。Ansible は、暗号化されたファイルを読み込んだり参照したりする際には、常に暗号化されたファイル全体を復号します。これは、Ansible は復号しない限りコンテンツが必要かどうかを知ることができないからです。

en: Creating encrypted files
ja: 暗号化されたファイルの作成

en: To create a new encrypted data file called 'foo.yml' with the 'test' vault password from 'multi_password_file':
ja: 「multi_password_file」の Vault "パスワード「test」を使って、「foo.yml」という名前の新しい暗号化データファイルを作成するには、以下を行います。

en: The tool launches an editor (whatever editor you have defined with $EDITOR, default editor is vi). Add the content. When you close the editor session, the file is saved as encrypted data. The file header reflects the vault ID used to create it:
ja: このツールは、エディター ($EDITOR で定義したエディターがなんであれ、デフォルトは vi) を起動します。コンテンツを追加します。エディターセッションを終了すると、ファイルは暗号化されたデータとして保存されます。ファイルのヘッダーには、作成時に使用した Vault ID が反映されます。

en: To create a new encrypted data file with the vault ID 'my_new_password' assigned to it and be prompted for the password:
ja: Vault ID「my_new_password」が割り当てられた新しい暗号化データファイルを作成し、パスワードの入力を求められるようにするには、以下を行います。

en: Again, add content to the file in the editor and save. Be sure to store the new password you created at the prompt, so you can find it when you want to decrypt that file.
ja: ここでも、エディターのファイルにコンテンツを追加して保存します。プロンプトで作成した新しいパスワードを必ず保存し、そのファイルを復号するときに見つけられるようにしてください。

en: Encrypting existing files
ja: 既存ファイルの暗号化

en: To encrypt an existing file, use the :ref:`ansible-vault encrypt <ansible_vault_encrypt>` command. This command can operate on multiple files at once. For example:
ja: 既存ファイルを暗号化するには、:ref:`ansible-vault encrypt <ansible_vault_encrypt>` コマンドを使用します。このコマンドは、一度に複数のファイルで動作します。以下に例を示します。

en: To encrypt existing files with the 'project' ID and be prompted for the password:
ja: 「プロジェクト」IDで既存のファイルを暗号化し、パスワードの入力を求めるプロンプトを表示するには、以下のようになります。

en: Viewing encrypted files
ja: 暗号化されたファイルの表示

en: To view the contents of an encrypted file without editing it, you can use the :ref:`ansible-vault view <ansible_vault_view>` command:
ja: 暗号化されたファイルの内容を編集せずに表示する場合は、:ref:`ansible-vault view <ansible_vault_view>` コマンドを使用できます。

en: Editing encrypted files
ja: 暗号化されたファイルの編集

en: To edit an encrypted file in place, use the :ref:`ansible-vault edit <ansible_vault_edit>` command. This command decrypts the file to a temporary file, allows you to edit the content, then saves and re-encrypts the content and removes the temporary file when you close the editor. For example:
ja: 暗号化されたファイルをその場で編集するには、:ref:`ansible-vault edit <ansible_vault_edit>` コマンドを使用します。このコマンドは、ファイルを一時的なファイルに復号し、内容を編集できるようにした後、内容を保存して再度暗号化し、エディターを閉じるときに一時的なファイルを削除します。以下に例を示します。

en: To edit a file encrypted with the ``vault2`` password file and assigned the vault ID ``pass2``:
ja: 「``vault2``」パスワードファイルで暗号化され、vault ID「``pass2``」を割り当てたファイルを編集するには、以下を実行します。

en: Changing the password and/or vault ID on encrypted files
ja: 暗号化されたファイルのパスワードまたは vault ID の変更

en: To change the password on an encrypted file or files, use the :ref:`rekey <ansible_vault_rekey>` command:
ja: 暗号化された 1 つまたは複数のファイルのパスワードを変更するには、:ref:`rekey <ansible_vault_rekey>` コマンドを使用します。

en: This command can rekey multiple data files at once and will ask for the original password and also the new password. To set a different ID for the rekeyed files, pass the new ID to ``--new-vault-id``. For example, to rekey a list of files encrypted with the 'preprod1' vault ID from the 'ppold' file to the 'preprod2' vault ID and be prompted for the new password:
ja: このコマンドは、複数のデータファイルの鍵を一度に設定することができ、元のパスワードと新しいパスワードを要求します。鍵を一度に設定したファイルに別の ID を設定するには、新しい ID を ``--new-vault-id`` に渡します。たとえば、「ppold」ファイルから「preprod1」の Vault ID で暗号化されたファイルのリストを Vault ID「preprod2」に鍵を再設定し、新しいパスワードの入力を求められる場合です。

en: Decrypting encrypted files
ja: 暗号化されたファイルの復号化

en: If you have an encrypted file that you no longer want to keep encrypted, you can permanently decrypt it by running the :ref:`ansible-vault decrypt <ansible_vault_decrypt>` command. This command will save the file unencrypted to the disk, so be sure you do not want to :ref:`edit <ansible_vault_edit>` it instead.
ja: 暗号化されたファイルがあり、そのファイルを暗号化したままにしておきたくない場合は、:ref:`ansible-vault decrypt <ansible_vault_decrypt>` コマンドを実行することで永久に暗号化を解除することができます。このコマンドは暗号化されていないファイルをディスクに保存するため、代わりに :ref:`edit <ansible_vault_edit>` を使用しないようにしてください。

en: Steps to secure your editor
ja: エディターを確保するための手順

en: Ansible Vault relies on your configured editor, which can be a source of disclosures. Most editors have ways to prevent loss of data, but these normally rely on extra plain text files that can have a clear text copy of your secrets. Consult your editor documentation to configure the editor to avoid disclosing secure data. The following sections provide some guidance on common editors but should not be taken as a complete guide to securing your editor.
ja: Ansible Vault は、設定されたエディターに依存しており、これが情報漏えいの原因となることがあります。ほとんどのエディターには、データの損失を防ぐ方法がありますが、通常は、秘密のコピーが平文で保存されている可能性のある追加の平文ファイルに依存しています。エディターのドキュメントを参照して、セキュアなデータの開示を回避するようにエディターを設定してください。以下のセクションでは、一般的なエディターに関するガイダンスを提供していますが、エディターのセキュリティーを確保するための完全なガイドと考えるべきではありません。

en: You can set the following ``vim`` options in command mode to avoid cases of disclosure. There may be more settings you need to modify to ensure security, especially when using plugins, so consult the ``vim`` documentation.
ja: 以下の ``vim`` オプションをコマンドモードで設定することで、情報漏えいのケースを回避することができます。特にプラグインを使用している場合など、セキュリティーを確保するために変更しなければならない設定が他にもあるかもしれないため、``vim`` のドキュメントを参照してください。

en: Disable swapfiles that act like an autosave in case of crash or interruption.
ja: クラッシュまたは中断が発生した場合に自動保存として機能する swapfiles を無効にします。

en: Disable creation of backup files.
ja: バックアップファイルの作成を無効にします。

en: Disable the viminfo file from copying data from your current session.
ja: viminfo ファイルを無効にして、現在のセッションからデータをコピーします。

en: Disable copying to the system clipboard.
ja: システムクリップボードへのコピーを無効にします。

en: You can optionally add these settings in ``.vimrc`` for all files, or just specific paths or extensions. See the ``vim`` manual for details.
ja: 必要に応じて、すべてのファイルまたは特定のパスまたは拡張の ``.vimrc`` にこれらの設定を追加できます。詳細は、``vim`` マニュアルを参照してください。

en: You can set the following Emacs options to avoid cases of disclosure. There may be more settings you need to modify to ensure security, especially when using plugins, so consult the Emacs documentation.
ja: 以下の Emacs オプションを設定することで、情報漏えいのケースを回避することができます。特にプラグインを使用する場合には、セキュリティーを確保するために変更する必要がある設定が他にもあるかもしれないため、Emacs のドキュメントを参照してください。

en: Do not copy data to the system clipboard.
ja: データをシステムクリップボードにコピーしないでください。

en: Disable autosave files.
ja: 自動保存ファイルを無効にします。

en: Using encrypted variables and files
ja: 暗号化された変数とファイルの使用

en: When you run a task or playbook that uses encrypted variables or files, you must provide the passwords to decrypt the variables or files. You can do this at the command line or in the playbook itself.
ja: 暗号化された変数やファイルを使用するタスクや Playbook を実行する際には、変数やファイルを復号するためのパスワードを提供する必要があります。これは、コマンドラインまたは Playbook 自体の中で行うことができます。

en: Passing a single password
ja: 単一のパスワードを渡す

en: If all the encrypted variables and files your task or playbook needs use a single password, you can use the :option:`--ask-vault-pass <ansible-playbook --ask-vault-pass>` or :option:`--vault-password-file <ansible-playbook --vault-password-file>` cli options.
ja: タスクや Playbook が必要とするすべての暗号化された変数やファイルが単一のパスワードを使用する場合は、CLI オプション :option:`--ask-vault-pass <ansible-playbook --ask-vault-pass>` または :option:`--vault-password-file <ansible-playbook --vault-password-file>` を使用できます。

en: To prompt for the password:
ja: パスワードを要求する場合は、以下のようになります。

en: To retrieve the password from the :file:`/path/to/my/vault-password-file` file:
ja: :file:`/path/to/my/vault-password-file` ファイルからパスワードを取得するには、以下を行います。

en: To get the password from the vault password client script :file:`my-vault-password-client.py`:
ja: 実行スクリプト :file:`my-vault-password-client.py` から vault パスワードを取得する場合は、以下のようになります。

en: Passing vault IDs
ja: Vault ID を渡す

en: You can also use the :option:`--vault-id <ansible-playbook --vault-id>` option to pass a single password with its vault label. This approach is clearer when multiple vaults are used within a single inventory.
ja: :option:`--vault-id <ansible-playbook --vault-id>` オプションを使用して、vault ラベルで単一のパスワードを渡すこともできます。このアプローチは、1 つのインベントリー内で複数の vault を使用している場合はより明確になります。

en: To prompt for the password for the 'dev' vault ID:
ja: vault ID「dev」のパスワードを要求する場合は、次のようになります。

en: To retrieve the password for the 'dev' vault ID from the :file:`dev-password` file:
ja: 「dev」の Vault ID のパスワードを :file:`dev-password` のファイルから取得するには、以下を行います。

en: To get the password for the 'dev' vault ID from the vault password client script :file:`my-vault-password-client.py`:
ja: 実行スクリプト :file:`my-vault-password-client.py` から vault ID 「dev」のパスワードを取得する場合は次のようになります。

en: Passing multiple vault passwords
ja: 複数の vault パスワードを渡す

en: If your task or playbook requires multiple encrypted variables or files that you encrypted with different vault IDs, you must use the :option:`--vault-id <ansible-playbook --vault-id>` option, passing multiple ``--vault-id`` options to specify the vault IDs ('dev', 'prod', 'cloud', 'db') and sources for the passwords (prompt, file, script). . For example, to use a 'dev' password read from a file and to be prompted for the 'prod' password:
ja: タスクや Playbook で、異なる Vault ID で暗号化した複数の暗号化された変数やファイルが必要な場合は、:option:`--vault-id <ansible-playbook --vault-id>` オプションを使用し、複数の ``--vault-id`` オプションを渡して Vault ID (「dev」、「prod」、「cloud」、「db」) とパスワードのソース (プロンプト、ファイル、スクリプト) を指定する必要があります。たとえば、ファイルから読み込んだ「dev」のパスワードを使用し、「prod」のパスワードを求めるプロンプトを表示する場合などです。

en: By default the vault ID labels (dev, prod and so on) are only hints. Ansible attempts to decrypt vault content with each password. The password with the same label as the encrypted data will be tried first, after that each vault secret will be tried in the order they were provided on the command line.
ja: デフォルトでは、Vault ID ラベル (dev、prodなど) はヒントでしかありません。Ansible は、各パスワードで Vault のコンテンツの復号を試みます。暗号化されたデータと同じラベルのパスワードが最初に試行され、その後、コマンドラインで指定された順に各 Vault シークレットが試行されます。

en: Where the encrypted data has no label, or the label does not match any of the provided labels, the passwords will be tried in the order they are specified. In the example above, the 'dev' password will be tried first, then the 'prod' password for cases where Ansible doesn't know which vault ID is used to encrypt something.
ja: 暗号化されたデータにラベルがない場合、またはラベルが提供されたラベルのどれとも一致しない場合、パスワードは指定された順に試行されます。上の例では、「dev」パスワードが最初に試行され、次に「prod」パスワードが試行されます。これは、Ansible がどの Vault ID が何かの暗号化に使用されているかを知らない場合のためです。

en: Using ``--vault-id`` without a vault ID
ja: vault ID なしで ``--vault-id`` を使用

en: The :option:`--vault-id <ansible-playbook --vault-id>` option can also be used without specifying a vault-id. This behavior is equivalent to :option:`--ask-vault-pass <ansible-playbook --ask-vault-pass>` or :option:`--vault-password-file <ansible-playbook --vault-password-file>` so is rarely used.
ja: :option:`--vault-id <ansible-playbook --vault-id>` オプションは、vault-id を指定せずに使用することもできます。この動作は :option:`--ask-vault-pass <ansible-playbook --ask-vault-pass>` または :option:`--vault-password-file <ansible-playbook --vault-password-file>` と同等であるため、ほとんど使用されません。

en: For example, to use a password file :file:`dev-password`:
ja: たとえば、パスワードファイル `dev-password` を使用する場合は、以下のようになります。

en: To get the password from an executable script :file:`my-vault-password-client.py`:
ja: 実行スクリプト :file:`my-vault-password-client.py` からパスワードを取得する場合は、以下のようになります。

en: Configuring defaults for using encrypted content
ja: 暗号化されたコンテンツを使用するためのデフォルトの設定

en: Setting a default vault ID
ja: デフォルトの Vault ID の設定

en: If you use one vault ID more frequently than any other, you can set the config option :ref:`DEFAULT_VAULT_IDENTITY_LIST` to specify a default vault ID and password source. Ansible will use the default vault ID and source any time you do not specify :option:`--vault-id <ansible-playbook --vault-id>`. You can set multiple values for this option. Setting multiple values is equivalent to passing multiple :option:`--vault-id <ansible-playbook --vault-id>` cli options.
ja: ある Vault ID を他の Vault IDよ りも頻繁に使用する場合は、設定オプション :ref:`DEFAULT_VAULT_IDENTITY_LIST` を設定して、デフォルトの Vault ID とパスワードソースを指定することができます。Ansible は、:option:`--vault-id <ansible-playbook --vault-id>` を指定しない場合は、デフォルトの Vault ID とソースを使用します。このオプションには複数の値を設定できます。複数の値を設定することは、複数の CLI オプション :option:`--vault-id <ansible-playbook --vault-id>` を渡すことと同じです。

en: Setting a default password source
ja: デフォルトのパスワードソースの設定

en: If you use one vault password file more frequently than any other, you can set the :ref:`DEFAULT_VAULT_PASSWORD_FILE` config option or the :envvar:`ANSIBLE_VAULT_PASSWORD_FILE` environment variable to specify that file. For example, if you set ``ANSIBLE_VAULT_PASSWORD_FILE=~/.vault_pass.txt``, Ansible will automatically search for the password in that file. This is useful if, for example, you use Ansible from a continuous integration system such as Jenkins.
ja: ある Vault パスワードファイルを他のファイルよりも頻繁に使用する場合は、:ref:`DEFAULT_VAULT_PASSWORD_FILE` 設定オプションまたは環境変数 :envvar:`ANSIBLE_VAULT_PASSWORD_FILE` を設定して、そのファイルを指定することができます。たとえば、``ANSIBLE_VAULT_PASSWORD_FILE=~/.vault_pass.txt`` を設定すると、Ansible は自動的にそのファイル内のパスワードを検索します。これは、たとえば、Jenkins などの継続的インテグレーションシステムから Ansible を使用する場合に便利です。

en: When are encrypted files made visible?
ja: 暗号化ファイルをいつ表示するか。

en: In general, content you encrypt with Ansible Vault remains encrypted after execution. However, there is one exception. If you pass an encrypted file as the ``src`` argument to the :ref:`copy <copy_module>`, :ref:`template <template_module>`, :ref:`unarchive <unarchive_module>`, :ref:`script <script_module>` or :ref:`assemble <assemble_module>` module, the file will not be encrypted on the target host (assuming you supply the correct vault password when you run the play). This behavior is intended and useful. You can encrypt a configuration file or template to avoid sharing the details of your configuration, but when you copy that configuration to servers in your environment, you want it to be decrypted so local users and processes can access it.
ja: 一般的に、Ansible Vault で暗号化したコンテンツは、実行後も暗号化されたままです。ただし、1 つだけ例外があります。:ref:`copy <copy_module>`、:ref:`template <template_module>`、:ref:`unarchive <unarchive_module>`、:ref:`script <script_module>`、または:ref:`assemble <assemble_module>` モジュールへの ``src`` 引数として暗号化されたファイルを渡した場合、そのファイルはターゲットホスト上では暗号化されません (プレイの実行時に正しい Vault パスワードを供給していることが前提です)。この動作は意図されたものであり、便利なものです。設定ファイルやテンプレートを暗号化して、設定の詳細を共有しないようにすることができますが、その設定を環境内のサーバーにコピーするときには、ローカルのユーザーやプロセスがアクセスできるように、暗号化を解除したいものです。

en: Speeding up Ansible Vault
ja: Ansible Vault のスピードアップ

en: If you have many encrypted files, decrypting them at startup may cause a perceptible delay. To speed this up, install the cryptography package:
ja: 多くの暗号化されたファイルがある場合、起動時にそれらを復号化すると、知覚できるほどの遅延が生じることがあります。これを高速化するには、暗号化パッケージをインストールします。

en: Format of files encrypted with Ansible Vault
ja: Ansible Vault で暗号化されたファイルの形式

en: Ansible Vault creates UTF-8 encoded txt files. The file format includes a newline terminated header. For example::
ja: Ansible Vault は、UTF-8 でエンコードされたテキストファイルを作成します。ファイル形式には、改行で終了するヘッダーが含まれます。以下に例を示します。

en: or::
ja: または::

en: The header contains up to four elements, separated by semi-colons (``;``).
ja: ヘッダーには、セミコロン (``;``) で区切られた最大 4 つの要素が含まれます。

en: The format ID (``$ANSIBLE_VAULT``). Currently ``$ANSIBLE_VAULT`` is the only valid format ID. The format ID identifies content that is encrypted with Ansible Vault (via vault.is_encrypted_file()).
ja: 形式 ID (``$ANSIBLE_VAULT``)。現在、``$ANSIBLE_VAULT`` は唯一の有効な形式 ID です。フォーマット ID は、(vault.is_encrypted_file() を介して) Ansible Vault で暗号化されているコンテンツを識別します。

en: The vault format version (``1.X``). All supported versions of Ansible will currently default to '1.1' or '1.2' if a labeled vault ID is supplied. The '1.0' format is supported for reading only (and will be converted automatically to the '1.1' format on write). The format version is currently used as an exact string compare only (version numbers are not currently 'compared').
ja: Vault 形式バージョン (``1.X``) です。現在、サポートされているすべてのバージョンの Ansible では、ラベル付きの Vault IDが指定された場合は、デフォルトで「1.1」または「1.2」になります。「1.0」形式は読み込みのみサポートしています (書き込み時には自動的に「1.1」形式に変換されます)。形式のバージョンは、現在、正確な文字列の比較としてのみ使用されています (バージョン番号は現在「比較」されません)。

en: The cipher algorithm used to encrypt the data (``AES256``). Currently ``AES256`` is the only supported cipher algorithm. Vault format 1.0 used 'AES', but current code always uses 'AES256'.
ja: データの暗号化に使用される暗号アルゴリズム (``AES256``)。現在、``AES256`` が唯一サポートされている暗号アルゴリズムです。Vault 形式 1.0 では「AES」を使用していましたが、現在のコードでは常に「AES256」を使用します。

en: The vault ID label used to encrypt the data (optional, ``vault-id-label``) For example, if you encrypt a file with ``--vault-id dev@prompt``, the vault-id-label is ``dev``.
ja: データの暗号化に使用される vault ID ラベル (任意: ``vault-id-label``) は、``--vault-id dev@prompt`` でファイルを暗号化する場合、vault-id-label が ``dev`` になります。

en: Note: In the future, the header could change. Fields after the format ID and format version depend on the format version, and future vault format versions may add more cipher algorithm options and/or additional fields.
ja: 注: 将来的には、ヘッダーが変更する可能性があります。形式 ID と形式バージョンの後のフィールドは、形式のバージョンに依存しており、将来の Vault 形式のバージョンでは、暗号アルゴリズムのオプションやフィールドが追加される可能性があります。

en: The rest of the content of the file is the 'vaulttext'. The vaulttext is a text armored version of the encrypted ciphertext. Each line is 80 characters wide, except for the last line which may be shorter.
ja: ファイルの残りの内容は「vaulttext」です。vaulttext は、暗号化された暗号文のテキスト装甲版です。各行の幅は 80 文字です。ただし、最終行は短くなる場合があります。

en: Ansible Vault payload format 1.1 - 1.2
ja: Ansible Vault ペイロード形式 1.1-1.2

en: The vaulttext is a concatenation of the ciphertext and a SHA256 digest with the result 'hexlifyied'.
ja: vault テキストは、暗号化テキストと SHA256 ダイジェストを連結したもので、結果は「hexlifyied」です。

en: 'hexlify' refers to the ``hexlify()`` method of the Python Standard Library's `binascii <https://docs.python.org/3/library/binascii.html>`_ module.
ja: 「hexlify」は、Python 標準ライブラリーの `binascii <https://docs.python.org/3/library/binascii.html>`_ モジュールの ``hexlify()`` メソッドを指します。

en: hexlify()'ed result of:
ja: hexlify() が行われた結果:

en: hexlify()'ed string of the salt, followed by a newline (``0x0a``)
ja: hexlify() で編集されたソルトの文字列とそれに続く改行 (``0x0a``)。

en: hexlify()'ed string of the crypted HMAC, followed by a newline. The HMAC is:
ja: hexlify() で暗号化された HMAC の文字列の後に、改行を入れます。その HMAC は以下のようになります。

en: a `RFC2104 <https://www.ietf.org/rfc/rfc2104.txt>`_ style HMAC
ja: `RFC2104 <https://www.ietf.org/rfc/rfc2104.txt>`_ スタイルの HMAC

en: inputs are:
ja: 入力は次のとおりです。

en: The AES256 encrypted ciphertext
ja: AES256 で暗号化した暗号文

en: A PBKDF2 key. This key, the cipher key, and the cipher IV are generated from:
ja: PBKDF2 キー。このキー、暗号キー、および暗号 IV を生成します。

en: the salt, in bytes
ja: バイト単位のソルト

en: 10000 iterations
ja: 10000 回の繰り返し

en: SHA256() algorithm
ja: SHA256() アルゴリズム

en: the first 32 bytes are the cipher key
ja: 最初の 32 バイトは暗号キーです。

en: the second 32 bytes are the HMAC key
ja: 2 番目の 32 バイトは HMAC キーです。

en: remaining 16 bytes are the cipher IV
ja: 残りの 16 バイトは暗号 IV です。

en: hexlify()'ed string of the ciphertext. The ciphertext is:
ja: 暗号文の hexlify() が行われた文字列です。暗号文は以下のようになります。

en: AES256 encrypted data. The data is encrypted using:
ja: AES256 で暗号化されたデータです。データは次を使用して暗号化されます。

en: AES-CTR stream cipher
ja: AES-CTR ストリーム暗号

en: cipher key
ja: 暗号鍵

en: a 128 bit counter block seeded from an integer IV
ja: 整数 IV から確認された 128 ビットカウンターブロック

en: the plaintext
ja: 平文

en: the original plaintext
ja: 元の平文

en: padding up to the AES256 blocksize. (The data used for padding is based on `RFC5652 <https://tools.ietf.org/html/rfc5652#section-6.3>`_)
ja: AES256 ブロックサイズまでのパディング (パディングに使用するデータは `RFC5652 <https://tools.ietf.org/html/rfc5652#section-6.3>`_ に基づいています)

en: Windows Guides
ja: Windows ガイド

en: The following sections provide information on managing Windows hosts with Ansible.
ja: 以下のセクションでは、Ansible を使用した Windows ホストの管理を説明します。

en: Because Windows is a non-POSIX-compliant operating system, there are differences between how Ansible interacts with them and the way Windows works. These guides will highlight some of the differences between Linux/Unix hosts and hosts running Windows.
ja: Windows は POSIX に準拠していない OS であるため、Ansible の動作方法と Windows の動作方法には違いがあります。このガイドでは、Linux/Unix ホストと Windows を実行するホストの違いを紹介します。

en: What is Desired State Configuration?
ja: Desired State Configuration とは

en: Desired State Configuration, or DSC, is a tool built into PowerShell that can be used to define a Windows host setup through code. The overall purpose of DSC is the same as Ansible, it is just executed in a different manner. Since Ansible 2.4, the ``win_dsc`` module has been added and can be used to leverage existing DSC resources when interacting with a Windows host.
ja: Desired State Configuration (DSC) は、PowerShell に組み込まれたツールで、コードによって Windows ホストのセットアップを定義するために使用することができます。DSC の全体的な目的は Ansible と同じですが、実行方法が異なるだけです。Ansible 2.4 からは、``win_dsc`` モジュールが追加され、Windows ホストとのやりとりの際に、既存の DSC リソースを活用することができます。

en: More details on DSC can be viewed at `DSC Overview <https://docs.microsoft.com/en-us/powershell/scripting/dsc/overview/overview>`_.
ja: DSC の詳細は「`DSC Overview <https://docs.microsoft.com/en-us/powershell/scripting/dsc/overview/overview>`_」を参照してください。

en: Host Requirements
ja: ホスト要件

en: To use the ``win_dsc`` module, a Windows host must have PowerShell v5.0 or newer installed. All supported hosts, except for Windows Server 2008 (non R2) can be upgraded to PowerShell v5.
ja: ``win_dsc`` モジュールを使用するには、Windows ホストに PowerShell v5.0 以降がインストールされている必要があります。Windows Server 2008 (R2 以外) を除くすべてのサポート対象ホストは、PowerShell v5.0 にアップグレードすることができます。

en: Once the PowerShell requirements have been met, using DSC is as simple as creating a task with the ``win_dsc`` module.
ja: PowerShell の要件を満たしていれば、DSC を使用することは、``win_dsc`` モジュールでタスクを作成するのと同じぐらい簡単です。

en: Why Use DSC?
ja: DSC を使用する理由

en: DSC and Ansible modules have a common goal which is to define and ensure the state of a resource. Because of this, resources like the DSC `File resource <https://docs.microsoft.com/en-us/powershell/scripting/dsc/reference/resources/windows/fileresource>`_ and Ansible ``win_file`` can be used to achieve the same result. Deciding which to use depends on the scenario.
ja: DSC と Ansible モジュールには、リソースの状態を定義して保証するという共通の目的があります。このため、DSC `ファイルリソース <https://docs.microsoft.com/en-us/powershell/scripting/dsc/reference/resources/windows/fileresource>`_ や Ansible``win_file`` のようなリソースを使用して、同じ結果を得ることができます。どちらを使用するかは、シナリオによって異なります。

en: Reasons for using an Ansible module over a DSC resource:
ja: DSC リソースで Ansible モジュールを使用する理由:

en: The host does not support PowerShell v5.0, or it cannot easily be upgraded
ja: ホストが PowerShell v5.0 をサポートしていない、または簡単にアップグレードできない。

en: The DSC resource does not offer a feature present in an Ansible module. For example win_regedit can manage the ``REG_NONE`` property type, while the DSC ``Registry`` resource cannot
ja: DSC リソースは、Ansible モジュールに存在する機能を提供しません。たとえば、win_regedit は ``REG_NONE`` のプロパティータイプを管理できますが、DSC ``Registry`` リソースではできません。

en: DSC resources have limited check mode support, while some Ansible modules have better checks
ja: DSC のリソースは確認モードのサポートが限られているが、Ansible モジュールの中にはより優れたチェック機能を持つものがある

en: DSC resources do not support diff mode, while some Ansible modules do
ja: DSC リソースでは差分モードがサポートされないが、一部の Ansible モジュールではサポートされる。

en: Custom resources require further installation steps to be run on the host beforehand, while Ansible modules are built-in to Ansible
ja: カスタムリソースでは、事前にホスト上で追加のインストール手順を実行する必要がありますが、Ansible モジュールは Ansible に組み込まれています。

en: There are bugs in a DSC resource where an Ansible module works
ja: Ansible モジュールが機能する DSC リソースにバグがある。

en: Reasons for using a DSC resource over an Ansible module:
ja: Ansible モジュールで DSC リソースを使用する理由:

en: The Ansible module does not support a feature present in a DSC resource
ja: Ansible モジュールは、DSC リソースに存在する機能をサポートしません。

en: There is no Ansible module available
ja: 利用可能な Ansible モジュールはありません。

en: There are bugs in an existing Ansible module
ja: 既存の Ansible モジュールにバグがある。

en: In the end, it doesn't matter whether the task is performed with DSC or an Ansible module; what matters is that the task is performed correctly and the playbooks are still readable. If you have more experience with DSC over Ansible and it does the job, just use DSC for that task.
ja: つまるところ、タスクが DSC で実行されるか Ansible モジュールで実行されるかは重要ではありません。重要なのは、タスクが正しく実行され、Playbook が読めることです。Ansible よりも DSC の方を使用した経験があり、それで問題が解決するのであれば、そのタスクには DSC を使用すると良いでしょう。

en: How to Use DSC?
ja: DSC の使用方法

en: The ``win_dsc`` module takes in a free-form of options so that it changes according to the resource it is managing. A list of built in resources can be found at `resources <https://docs.microsoft.com/en-us/powershell/scripting/dsc/resources/resources>`_.
ja: ``win_dsc`` モジュールは、管理しているリソースに応じて変化するように、自由形式のオプションを取り入れています。組み込まれているリソースのリストは「`リソース <https://docs.microsoft.com/en-us/powershell/scripting/dsc/resources/resources>`_」を参照してください。

en: Using the `Registry <https://docs.microsoft.com/en-us/powershell/scripting/dsc/reference/resources/windows/registryresource>`_ resource as an example, this is the DSC definition as documented by Microsoft:
ja: `Registry <https://docs.microsoft.com/en-us/powershell/scripting/dsc/reference/resources/windows/registryresource>`_ リソースを例にとると、これは Microsoft が文書化したDSCの定義です。

en: When defining the task, ``resource_name`` must be set to the DSC resource being used - in this case the ``resource_name`` should be set to ``Registry``. The ``module_version`` can refer to a specific version of the DSC resource installed; if left blank it will default to the latest version. The other options are parameters that are used to define the resource, such as ``Key`` and ``ValueName``. While the options in the task are not case sensitive, keeping the case as-is is recommended because it makes it easier to distinguish DSC resource options from Ansible's ``win_dsc`` options.
ja: タスクを定義する際には、使用する DSC リソースを ``resource_name`` に設定する必要があります。この場合、``resource_name`` は ``Registry`` に設定する必要があります。``module_version`` はインストールされている DSC リソースの特定のバージョンを参照することができますが、空白にするとデフォルトで最新のバージョンになります。その他のオプションは ``Key`` や ``ValueName`` のようにリソースを定義するためのパラメーターになります。タスクのオプションは大文字小文字を区別しませんが、DSC リソースのオプションと Ansible の``win_dsc`` のオプションを区別しやすくするために、大文字小文字をそのままにしておくことが推奨されます。

en: This is what the Ansible task version of the above DSC Registry resource would look like:
ja: 上記の DSC レジストリーリソースの Ansible タスクバージョンは、以下のようになります。

en: Starting in Ansible 2.8, the ``win_dsc`` module automatically validates the input options from Ansible with the DSC definition. This means Ansible will fail if the option name is incorrect, a mandatory option is not set, or the value is not a valid choice. When running Ansible with a verbosity level of 3 or more (``-vvv``), the return value will contain the possible invocation options based on the ``resource_name`` specified. Here is an example of the invocation output for the above ``Registry`` task:
ja: Ansible 2.8 より、``win_dsc`` モジュールは、Ansible からの入力オプションを DSC 定義で自動的に検証します。つまり、オプション名が間違っていたり、必須オプションが設定されていなかったり、値が有効な選択肢でなかったりすると、Ansible は失敗します。Ansible を冗長レベル 3 以上 (``-vvv``) で実行した場合、戻り値には、指定された ``resource_name`` に基づいて可能な呼び出しオプションが含まれます。以下は、上記の ``Registry`` タスクの呼び出し出力の例です。

en: The ``invocation.module_args`` key shows the actual values that were set as well as other possible values that were not set. Unfortunately this will not show the default value for a DSC property, only what was set from the Ansible task. Any ``*_password`` option will be masked in the output for security reasons, if there are any other sensitive module options, set ``no_log: True`` on the task to stop all task output from being logged.
ja: ``invocation.module_args`` キーは、設定された実際の値と、設定されなかった他の可能な値を表示します。残念ながら DSC プロパティーのデフォルト値は表示されず、Ansible タスクで設定された値のみが表示されます。``*_password`` オプションは、セキュリティー上の理由から出力ではマスクされます。他に機密性の高いモジュールオプションがある場合は、タスクに ``no_log: True`` を設定して、すべてのタスク出力がログに記録されないようにしてください。

en: Property Types
ja: プロパティータイプ

en: Each DSC resource property has a type that is associated with it. Ansible will try to convert the defined options to the correct type during execution. For simple types like ``[string]`` and ``[bool]`` this is a simple operation, but complex types like ``[PSCredential]`` or arrays (like ``[string[]]``) this require certain rules.
ja: 各 DSC リソースプロパティーには、それに関連付けられたタイプがあります。Ansible は、実行時に定義されたオプションを正しい型に変換しようとします。``[string]`` や ``[bool]`` のような単純な型では、これは単純な操作ですが、``[PSCredential]`` や配列 (``[string[]]`` など) のような複雑な型では、特定のルールが必要です。

en: A ``[PSCredential]`` object is used to store credentials in a secure way, but Ansible has no way to serialize this over JSON. To set a DSC PSCredential property, the definition of that parameter should have two entries that are suffixed with ``_username`` and ``_password`` for the username and password respectively. For example:
ja: ``[PSCredential]`` オブジェクトは認証情報を安全な方法で保存するために使用されますが、Ansible にはこれを JSON でシリアル化する方法がありません。DSC PSCredential プロパティーを設定するには、そのパラメーターの定義に、ユーザ名とパスワードをそれぞれ ``_username`` と``_password`` をサフィックスにした 2 つのエントリーを追加する必要があります。たとえば、以下のようになります。

en: On versions of Ansible older than 2.8, you should set ``no_log: yes`` on the task definition in Ansible to ensure any credentials used are not stored in any log file or console output.
ja: 2.8 より古いバージョンの Ansible では、Ansible のタスク定義に ``no_log: yes`` を設定して、使用する認証情報がログファイルまたはコンソールの出力に保存されないようにする必要があります。

en: A ``[PSCredential]`` is defined with ``EmbeddedInstance("MSFT_Credential")`` in a DSC resource MOF definition.
ja: ``[PSCredential]`` は、DSC リソースの MOF 定義において``EmbeddedInstance("MSFT_Credential")`` と共に定義されます。

en: CimInstance Type
ja: CimInstance タイプ

en: A ``[CimInstance]`` object is used by DSC to store a dictionary object based on a custom class defined by that resource. Defining a value that takes in a ``[CimInstance]`` in YAML is the same as defining a dictionary in YAML. For example, to define a ``[CimInstance]`` value in Ansible:
ja: ``[CimInstance]`` オブジェクトは、DSC がそのリソースで定義されたカスタムクラスに基づいてディクショナリーオブジェクトを格納するために使用されます。``[CimInstance]`` を取り込む値を YAML で定義することは、YAML でディクショナリーを定義することと同じです。たとえば、Ansible で``[CimInstance]`` の値を定義する場合は、以下のようになります。

en: In the above example, the CIM instance is a representation of the class `MSFT_xWebAuthenticationInformation <https://github.com/dsccommunity/xWebAdministration/blob/master/source/DSCResources/MSFT_xWebSite/MSFT_xWebSite.schema.mof>`_. This class accepts four boolean variables, ``Anonymous``, ``Basic``, ``Digest``, and ``Windows``. The keys to use in a ``[CimInstance]`` depend on the class it represents. Please read through the documentation of the resource to determine the keys that can be used and the types of each key value. The class definition is typically located in the ``<resource name>.schema.mof``.
ja: 上記の例では、CIM インスタンスは、クラス `MSFT_xWebAuthenticationInformation <https://github.com/dsccommunity/xWebAdministration/blob/master/source/DSCResources/MSFT_xWebSite/MSFT_xWebSite.schema.mof>`_ の表現です。このクラスは、``Anonymous``,``Basic``,``Digest``,``Windows`` という 4 つのブール変数を受け入れます。``[CimInstance]`` で使用するキーは、それが表現するクラスによって異なります。使用できるキーと各キーの値の種類については、リソースのドキュメントに目を通してください。クラスの定義は、通常、``<resource name>.schema.mof`` にあります。

en: HashTable Type
ja: HashTable タイプ

en: A ``[HashTable]`` object is also a dictionary but does not have a strict set of keys that can/need to be defined. Like a ``[CimInstance]``, define it like a normal dictionary value in YAML. A ``[HashTable]]`` is defined with ``EmbeddedInstance("MSFT_KeyValuePair")`` in a DSC resource MOF definition.
ja: ``[HashTable]`` オブジェクトもディクショナリーですが、定義できる/しなければならない厳密な鍵のセットを持っていません。``[CimInstance]`` のように、YAML で通常のディクショナリー値のように定義します。``[HashTable]]`` は、DSC リソースの MOF 定義において ``EmbeddedInstance("MSFT_KeyValuePair")`` と共に定義されます。

en: Arrays
ja: 配列

en: Simple type arrays like ``[string[]]`` or ``[UInt32[]]`` are defined as a list or as a comma separated string which are then cast to their type. Using a list is recommended because the values are not manually parsed by the ``win_dsc`` module before being passed to the DSC engine. For example, to define a simple type array in Ansible:
ja: ``[string[]]`` や ``[UInt32[]]`` のような単純な型の配列は、リストまたはカンマ区切りの文字列として定義され、それらが型にキャストされます。リストを使用すると、DSC エンジンに渡す前に ``win_dsc`` モジュールで値が手動で解析されないため、推奨されます。たとえば、Ansible で単純な型の配列を定義するには、次のようにします。

en: Complex type arrays like ``[CimInstance[]]`` (array of dicts), can be defined like this example:
ja: ``[CimInstance[]]`` (ディクショナリーの配列) のような複雑な型の配列は、次の例のように定義できます。

en: The above example, is an array with two values of the class `MSFT_xWebBindingInformation <https://github.com/dsccommunity/xWebAdministration/blob/master/source/DSCResources/MSFT_xWebSite/MSFT_xWebSite.schema.mof>`_. When defining a ``[CimInstance[]]``, be sure to read the resource documentation to find out what keys to use in the definition.
ja: 上記の例は、`MSFT_xWebBindingInformation <https://github.com/dsccommunity/xWebAdministration/blob/master/source/DSCResources/MSFT_xWebSite/MSFT_xWebSite.schema.mof>`_ クラスの 2 つの値のある配列です。``[CimInstance[]]`` を定義すると、リソースドキュメントを参照して、定義で使用するキーを確認してください。

en: DateTime
ja: 日時

en: A ``[DateTime]`` object is a DateTime string representing the date and time in the `ISO 8601 <https://www.w3.org/TR/NOTE-datetime>`_ date time format. The value for a ``[DateTime]`` field should be quoted in YAML to ensure the string is properly serialized to the Windows host. Here is an example of how to define a ``[DateTime]`` value in Ansible:
ja: ``[DateTime]`` オブジェクトは、`ISO 8601 <https://www.w3.org/TR/NOTE-datetime>`_ の日付時間フォーマットで日付と時間を表す DateTime 文字列です。``[DateTime]`` フィールドの値は、文字列が Windows ホストに適切にシリアライズされるように、YAML で引用する必要があります。以下は、Ansible で``[DateTime]`` の値を定義する方法の例です。

en: All the values above are equal to a UTC date time of February 22nd 2019 at 1:57pm with 31 seconds and 2311892 milliseconds.
ja: 上記のすべての値は、UTCの 日付時刻が 2019 年 2 月 22 日午後 1 時 57 分 31秒 2311892 ミリ秒であることと同じです。

en: Run As Another User
ja: 別のユーザーとして実行

en: By default, DSC runs each resource as the SYSTEM account and not the account that Ansible use to run the module. This means that resources that are dynamically loaded based on a user profile, like the ``HKEY_CURRENT_USER`` registry hive, will be loaded under the ``SYSTEM`` profile. The parameter ``PsDscRunAsCredential`` is a parameter that can be set for every DSC resource force the DSC engine to run under a different account. As ``PsDscRunAsCredential`` has a type of ``PSCredential``, it is defined with the ``_username`` and ``_password`` suffix.
ja: デフォルトでは、DSC は各リソースを、Ansible がモジュールの実行に使用するアカウントではなく、SYSTEM アカウントとして実行します。つまり、``HKEY_CURRENT_USER`` のレジストリーハイブのように、ユーザープロファイルに基づいて動的に読み込まれるリソースは、``SYSTEM`` のプロファイルで読み込まれます。``PsDscRunAsCredential`` は、DSC エンジンが別のアカウントで実行されるように、すべての DSC リソースに設定することができるパラメーターです。``PsDscRunAsCredential`` はタイプが ``PSCredential`` なので、``_username`` と``_password`` というサフィックスで定義されています。

en: Using the Registry resource type as an example, this is how to define a task to access the ``HKEY_CURRENT_USER`` hive of the Ansible user:
ja: レジストリーリソースタイプを例として使用し、Ansible ユーザーの ``HKEY_CURRENT_USER`` ハイブにアクセスするタスクを定義する方法を説明します。

en: Custom DSC Resources
ja: カスタムの DSC リソース

en: DSC resources are not limited to the built-in options from Microsoft. Custom modules can be installed to manage other resources that are not usually available.
ja: DSC のリソースは、Microsoft の組み込みオプションに限定されません。カスタムモジュールをインストールすることで、通常では利用できない他のリソースを管理することができます。

en: Finding Custom DSC Resources
ja: カスタムの DSC リソースの見つけ方

en: You can use the `PSGallery <https://www.powershellgallery.com/>`_ to find custom resources, along with documentation on how to install them  on a Windows host.
ja: `PSGallery <https://www.powershellgallery.com/>`_ を使用すると、カスタムリソースと、それを Windows ホストにインストールする方法に関するドキュメントを見つけることができます。

en: The ``Find-DscResource`` cmdlet can also be used to find custom resources. For example:
ja: ``Find-DscResource`` コマンドレットを使用して、カスタムリソースを検索することもできます。以下に例を示します。

en: DSC resources developed by Microsoft that start with ``x``, means the resource is experimental and comes with no support.
ja: Microsoft が開発した DSC リソースで、``x`` で始まるものは、実験的なリソースであり、サポートがないことを意味しています。

en: Installing a Custom Resource
ja: カスタムリソースのインストール

en: There are three ways that a DSC resource can be installed on a host:
ja: DSC リソースをホストにインストールする方法は 3 つあります。

en: Manually with the ``Install-Module`` cmdlet
ja: ``Install-Module`` コマンドレットを手動で使用

en: Using the ``win_psmodule`` Ansible module
ja: Ansibleモジュール ``win_psmodule`` を使用

en: Saving the module manually and copying it another host
ja: モジュールを手動で保存して別のホストにコピー

en: This is an example of installing the ``xWebAdministration`` resources using ``win_psmodule``:
ja: これは、``win_psmodule`` を使用して ``xWebAdministration`` リソースをインストールする例です。

en: Once installed, the win_dsc module will be able to use the resource by referencing it with the ``resource_name`` option.
ja: インストールすると、win_dsc モジュールは、``resource_name`` オプションでリソースを参照することで、リソースを使用できるようになります。

en: The first two methods above only work when the host has access to the internet. When a host does not have internet access, the module must first be installed using the methods above on another host with internet access and then copied across. To save a module to a local filepath, the following PowerShell cmdlet can be run::
ja: 上記の最初の 2 つの方法は、ホストがインターネットにアクセスできる場合にのみ機能します。ホストがインターネットにアクセスできない場合は、まずインターネットにアクセスできる別のホスト上で上記の方法を使用してモジュールをインストールし、それをコピーする必要があります。モジュールをローカルのファイルパスに保存するには、次の PowerShell コマンドレットを実行します。

en: This will create a folder called ``xWebAdministration`` in ``C:\temp`` which can be copied to any host. For PowerShell to see this offline resource, it must be copied to a directory set in the ``PSModulePath`` environment variable. In most cases the path ``C:\Program Files\WindowsPowerShell\Module`` is set through this variable, but the ``win_path`` module can be used to add different paths.
ja: これにより、``C:\temp`` の中に``xWebAdministration`` というフォルダーが作成され、どのホストにもコピーできるようになります。PowerShell がこのオフラインリソースを見るためには、環境変数 ``PSModulePath`` で設定されたディレクトリーにコピーされている必要があります。ほとんどの場合、この変数を通じてパス ``C:\Program Files\WindowsPowerShell\Module`` が設定されますが、``win_path`` モジュールを使用して異なるパスを追加することができます。

en: Examples
ja: 例

en: Extract a zip file
ja: zip ファイルの展開

en: Create a directory
ja: ディレクトリーの作成

en: Interact with Azure
ja: Azure の操作

en: Setup IIS Website
ja: IIS Web サイトのセットアップ

en: Windows specific module list, all implemented in PowerShell
ja: Windows 固有のモジュールリスト (すべて PowerShell に実装)

en: Windows Frequently Asked Questions
ja: Windows に関するよくある質問 (FAQ)

en: Here are some commonly asked questions in regards to Ansible and Windows and their answers.
ja: ここでは、Ansible および Windows に関するよくある質問とその回答を紹介します。

en: This document covers questions about managing Microsoft Windows servers with Ansible. For questions about Ansible Core, please see the :ref:`general FAQ page <ansible_faq>`.
ja: 本ガイドでは、Ansible を使用した Microsoft Windows サーバーの管理に関する質問について説明します。Ansible Core に関する質問は、「:ref:`一般的な FAQ ページ <ansible_faq>`」を参照してください。

en: Does Ansible work with Windows XP or Server 2003?
ja: Ansible は、Windows XP または Server 2003 で動作しますか

en: Ansible does not work with Windows XP or Server 2003 hosts. Ansible does work with these Windows operating system versions:
ja: Ansible は、Windows XP または Server 2003 ホストでは動作しません。Ansible は、以下の Windows オペレーティングシステムバージョンで動作します。

en: 1 - See the :ref:`Server 2008 FAQ <windows_faq_server2008>` entry for more details.
ja: 1 - 詳細は、:ref:`Server 2008 FAQ <windows_faq_server2008>` のエントリーを参照してください。

en: Ansible also has minimum PowerShell version requirements - please see :ref:`windows_setup` for the latest information.
ja: また、Ansible には PowerShell の最小バージョン要件があります。最新情報は「:ref:`windows_setup`」を参照してください。

en: Are Server 2008, 2008 R2 and Windows 7 supported?
ja: Server 2008、2008 R2、Windows 7 に対応していますか

en: Microsoft ended Extended Support for these versions of Windows on January 14th, 2020, and Ansible deprecated official support in the 2.10 release. No new feature development will occur targeting these operating systems, and automated testing has ceased. However, existing modules and features will likely continue to work, and simple pull requests to resolve issues with these Windows versions may be accepted.
ja: Microsoft は 2020 年 1 月 14 日にこれらのバージョンの Windows の Extended Support を終了し、Ansible は 2.10 のリリースで公式サポートを廃止しました。これらのオペレーティングシステムを対象とした新機能の開発は行われず、自動テストも終了しています。しかし、既存のモジュールや機能は引き続き動作する可能性があり、これらの Windows バージョンに関する問題を解決するための簡単なプル要求は承認される可能性があります。

en: Can I manage Windows Nano Server with Ansible?
ja: Ansible で Windows Nano Server を管理できますか

en: Ansible does not currently work with Windows Nano Server, since it does not have access to the full .NET Framework that is used by the majority of the modules and internal components.
ja: Ansible は現在、Windows Nano Server では動作しません。これは、大部分のモジュールや内部コンポーネントで使用されている完全な .NET フレームワークにアクセスできないためです。

en: Can Ansible run on Windows?
ja: Ansible は Windows で実行できますか

en: No, Ansible can only manage Windows hosts. Ansible cannot run on a Windows host natively, though it can run under the Windows Subsystem for Linux (WSL).
ja: いいえ、Ansible は Windows ホストのみを管理できます。Ansible は Windows ホスト上ではネイティブに実行できませんが、Windows Subsystem for Linux (WSL) の下で実行できます。

en: The Windows Subsystem for Linux is not supported by Ansible and should not be used for production systems.
ja: Windows Subsystem for Linux は Ansible ではサポートされていないため、実稼働システムには使用しないでください。

en: To install Ansible on WSL, the following commands can be run in the bash terminal:
ja: WSL に Ansible をインストールするには、bash ターミナルで以下のコマンドを実行します。

en: To run Ansible from source instead of a release on the WSL, simply uninstall the pip installed version and then clone the git repo.
ja: WSL のリリースではなくソースから Ansible を実行するには、インストールした pip をアンインストールし、git リポジトリーのクローンを作成します。

en: If you encounter timeout errors when running Ansible on the WSL, this may be due to an issue with ``sleep`` not returning correctly. The following workaround may resolve the issue:
ja: WSL 上で Ansible を実行したときにタイムアウトエラーが発生する場合は、``sleep`` が正しく返されない問題が原因となる可能性があります。以下の回避策により、この問題が解決される場合があります。

en: Another option is to use WSL 2 if running Windows 10 later than build 2004.
ja: 別のオプションとして、ビルド 2004 よりも Windows 10 以上を実行している場合は WSL 2 を使用します。

en: Can I use SSH keys to authenticate to Windows hosts?
ja: SSH キーを使用して Windows ホストへの認証を行うことはできますか

en: You cannot use SSH keys with the WinRM or PSRP connection plugins. These connection plugins use X509 certificates for authentication instead of the SSH key pairs that SSH uses.
ja: WinRM または PSRP 接続プラグインで SSH 鍵を使用することはできません。これらの接続プラグインは、SSH が使用する SSH キーペアの代わりに、認証に X509 証明書を使用します。

en: The way X509 certificates are generated and mapped to a user is different from the SSH implementation; consult the :ref:`windows_winrm` documentation for more information.
ja: X509 証明書が生成され、ユーザーにマッピングされる方法は、SSH の実装とは異なります。詳細は、:ref:`windows_winrm` のドキュメントを参照してください。

en: Ansible 2.8 has added an experimental option to use the SSH connection plugin, which uses SSH keys for authentication, for Windows servers. See :ref:`this question <windows_faq_ssh>` for more information.
ja: Ansible 2.8 には、認証に SSH 鍵を使用する SSH 接続プラグインを Windows サーバーで使用する実験的なオプションが追加されました。詳細は「:ref:`this question <windows_faq_ssh>`」を参照してください。

en: Why can I run a command locally that does not work under Ansible?
ja: Ansible で機能しないコマンドをローカルで実行できるのはなぜですか

en: Ansible executes commands through WinRM. These processes are different from running a command locally in these ways:
ja: Ansible は、WinRM を介してコマンドを実行します。これらのプロセスは、以下の方法でローカルでコマンドを実行するのとは異なります。

en: Unless using an authentication option like CredSSP or Kerberos with credential delegation, the WinRM process does not have the ability to delegate the user's credentials to a network resource, causing ``Access is Denied`` errors.
ja: CredSSP や Kerberos のような認証オプションを使用して、認証情報の委譲を行っていない限り、WinRM プロセスにはユーザーの認証情報をネットワークリソースに委譲する機能がなく、``Access is Denied`` エラーが発生します。

en: All processes run under WinRM are in a non-interactive session. Applications that require an interactive session will not work.
ja: WinRM で実行されるすべてのプロセスは、非対話型セッションです。対話型セッションを必要とするアプリケーションは機能しません。

en: When running through WinRM, Windows restricts access to internal Windows APIs like the Windows Update API and DPAPI, which some installers and programs rely on.
ja: WinRM を介して実行する場合、Windows は、一部のインストーラーやプログラムが依存している Windows Update API や DPAPI などの Windows 内部 API へのアクセスを制限します。

en: Some ways to bypass these restrictions are to:
ja: これらの制限を回避する方法は次のとおりです。

en: Use ``become``, which runs a command as it would when run locally. This will bypass most WinRM restrictions, as Windows is unaware the process is running under WinRM when ``become`` is used. See the :ref:`become` documentation for more information.
ja: ``become`` を使用すると、ローカルで実行するときと同じようにコマンドを実行できます。``become`` を使用すると、Windows はプロセスが WinRM の下で実行されていることに気づかないため、ほとんどの WinRM の制限を回避することができます。詳細は、:ref:`become` のドキュメントを参照してください。

en: Use a scheduled task, which can be created with ``win_scheduled_task``. Like ``become``, it will bypass all WinRM restrictions, but it can only be used to run commands, not modules.
ja: ``win_scheduled_task`` で作成できる、スケジュールされたタスクを使用します。``become`` と同様に、WinRM の制限をすべて回避できますが、モジュールではなくコマンドの実行にのみ使用できます。

en: Use ``win_psexec`` to run a command on the host. PSExec does not use WinRM and so will bypass any of the restrictions.
ja: ``win_psexec`` を使用してホストでコマンドを実行します。PSExec は WinRM を使用しないため、あらゆる制限を回避することができます。

en: To access network resources without any of these workarounds, you can use CredSSP or Kerberos with credential delegation enabled.
ja: これらの回避策を取らずにネットワークリソースにアクセスするには、認証情報の委譲を有効にした CredSSP または Kerberos を使用することができます。

en: See :ref:`become` more info on how to use become. The limitations section at :ref:`windows_winrm` has more details around WinRM limitations.
ja: become の使用方法に関する詳細の詳細は、「:ref:`become`」を参照してください。:ref:`windows_winrm` の制限セクションには、WinRM 制限の詳細が記載されています。

en: This program won't install on Windows with Ansible
ja: このプログラムが、Ansible がインストールされている Windows にはインストールされません

en: See :ref:`this question <windows_faq_winrm>` for more information about WinRM limitations.
ja: WinRMの制限の詳細は、「:ref:`こちらの質問 <windows_faq_winrm>`」を参照してください。

en: What Windows modules are available?
ja: どのような Windows モジュールが利用できますか

en: Most of the Ansible modules in Ansible Core are written for a combination of Linux/Unix machines and arbitrary web services. These modules are written in Python and most of them do not work on Windows.
ja: Ansible Core の Ansible モジュールの多くは、Linux/Unix マシンと任意の Web サービスの組み合わせを想定して記述されます。これらのモジュールは Python で記述されており、そのほとんどが Windows では動作しません。

en: Because of this, there are dedicated Windows modules that are written in PowerShell and are meant to be run on Windows hosts. A list of these modules can be found :ref:`here <windows_modules>`.
ja: このため、PowerShell で記述されており、Windows ホストで実行することを目的としている専用の Windows モジュールがあります。これらのモジュールの一覧は、「:ref:`here <windows_modules>` 」にあります。

en: In addition, the following Ansible Core modules/action-plugins work with Windows:
ja: 次の Ansible Core モジュールおよびアクションプラグインは、Windows で動作します。

en: template (also: win_template)
ja: template (win_template も同様)

en: Can I run Python modules on Windows hosts?
ja: Windows ホストで Python モジュールを実行できますか

en: No, the WinRM connection protocol is set to use PowerShell modules, so Python modules will not work. A way to bypass this issue to use ``delegate_to: localhost`` to run a Python module on the Ansible controller. This is useful if during a playbook, an external service needs to be contacted and there is no equivalent Windows module available.
ja: できません。WinRM 接続プロトコルは PowerShell モジュールを使用するように設定されているため、Python モジュールは動作しません。この問題を回避するには、``delegate_to: localhost`` を使用して Ansible コントローラー上で Python モジュールを実行する方法があります。これは、Playbook 中に外部サービスに接続する必要があり、同等の Windows モジュールがない場合に便利です。

en: Can I connect to Windows hosts over SSH?
ja: SSH 経由で Windows ホストに接続できますか

en: Ansible 2.8 has added an experimental option to use the SSH connection plugin to manage Windows hosts. To connect to Windows hosts over SSH, you must install and configure the `Win32-OpenSSH <https://github.com/PowerShell/Win32-OpenSSH>`_ fork that is in development with Microsoft on the Windows host(s). While most of the basics should work with SSH, ``Win32-OpenSSH`` is rapidly changing, with new features added and bugs fixed in every release. It is highly recommend you `install <https://github.com/PowerShell/Win32-OpenSSH/wiki/Install-Win32-OpenSSH>`_ the latest release of ``Win32-OpenSSH`` from the GitHub Releases page when using it with Ansible on Windows hosts.
ja: Ansible 2.8 には、SSH 接続プラグインを使用して Windows ホストを管理する実験的なオプションが追加されました。Windows ホストに SSH 接続するには、Microsoft と共同で開発中の `Win32-OpenSSH <https://github.com/PowerShell/Win32-OpenSSH>`_ フォークを Windows ホストにインストールして設定する必要があります。基本的な機能のほとんどは SSH で動作するはずですが、``Win32-OpenSSH`` はリリースごとに新機能が追加されたり、バグが修正されたりと、急速に変化しています。Windows ホストで Ansible を使用する際には、GitHub Releases ページから ``Win32-OpenSSH`` の最新リリースを `インストール <https://github.com/PowerShell/Win32-OpenSSH/wiki/Install-Win32-OpenSSH>`_ することが強く推奨されます。

en: To use SSH as the connection to a Windows host, set the following variables in the inventory::
ja: Windows ホストへの接続に SSH を使用するには、インベントリーに以下の変数を設定します。

en: The value for ``ansible_shell_type`` should either be ``cmd`` or ``powershell``. Use ``cmd`` if the ``DefaultShell`` has not been configured on the SSH service and ``powershell`` if that has been set as the ``DefaultShell``.
ja: ``ansible_shell_type`` の値は、``cmd`` または ``powershell`` のいずれかでなければなりません。SSH サービスで ``DefaultShell`` が設定されていない場合は ``cmd`` を使用して、``DefaultShell`` として設定されている場合は ``powershell`` を使用してください。

en: Why is connecting to a Windows host via SSH failing?
ja: SSH 経由で Windows ホストに接続できないのはなぜですか

en: Unless you are using ``Win32-OpenSSH`` as described above, you must connect to Windows hosts using :ref:`windows_winrm`. If your Ansible output indicates that SSH was used, either you did not set the connection vars properly or the host is not inheriting them correctly.
ja: 上記のように ``Win32-OpenSSH`` を使用している場合を除き、Windows ホストへの接続には :ref:`windows_winrm` を使用する必要があります。Ansible の出力で SSH が使用されたと表示された場合は、接続バーが正しく設定されていないか、ホストに正しく継承されていません。

en: Make sure ``ansible_connection: winrm`` is set in the inventory for the Windows host(s).
ja: Windows ホストのインベントリーに ``ansible_connection: winrm`` が設定されていることを確認してください。

en: Why are my credentials being rejected?
ja: 認証情報が拒否されるのはなぜですか

en: This can be due to a myriad of reasons unrelated to incorrect credentials.
ja: これは、誤った認証情報とは無関係の、多種多様なものが原因である可能性があります。

en: See HTTP 401/Credentials Rejected at :ref:`windows_setup` for a more detailed guide of this could mean.
ja: この現象の詳細については、:ref:`windows_setup` の「HTTP 401/認証情報の拒否」を参照してください。

en: Why am I getting an error SSL CERTIFICATE_VERIFY_FAILED?
ja: SSL CERTIFICATE_VERIFY_FAILED エラーが発生するのはなぜですか

en: When the Ansible controller is running on Python 2.7.9+ or an older version of Python that has backported SSLContext (like Python 2.7.5 on RHEL 7), the controller will attempt to validate the certificate WinRM is using for an HTTPS connection. If the certificate cannot be validated (such as in the case of a self signed cert), it will fail the verification process.
ja: Ansible コントローラーが Python 2.7.9 以降または SSLContext をバックポートした古いバージョンの Python (RHEL 7 の Python 2.7.5 など) で動作している場合、コントローラーは WinRM が HTTPS 接続に使用している証明書を検証しようとします。証明書を検証できない場合 (自己署名証明書の場合など) は、検証プロセスに失敗します。

en: To ignore certificate validation, add ``ansible_winrm_server_cert_validation: ignore`` to inventory for the Windows host.
ja: 証明書の検証を無視するには、Windows ホストのインベントリーに ``ansible_winrm_server_cert_validation: ignore`` を追加してください。

en: The Windows documentation index
ja: Windows ドキュメントの目次

en: Windows performance
ja: Windows パフォーマンス

en: This document offers some performance optimizations you might like to apply to your Windows hosts to speed them up specifically in the context of using Ansible with them, and generally.
ja: 本書では、特に Ansible をそのホストで使用する状況、および一般的に使用する状況で高速化するために、Windows ホストに適用するパフォーマンスの最適化をいくつか紹介します。

en: Optimise PowerShell performance to reduce Ansible task overhead
ja: Ansible タスクのオーバーヘッドを軽減するための PowerShell のパフォーマンスの最適化

en: To speed up the startup of PowerShell by around 10x, run the following PowerShell snippet in an Administrator session. Expect it to take tens of seconds.
ja: PowerShell の起動を約 10 倍高速化するには、Administrator セッションで以下の PowerShell スニペットを実行します。数十秒かかることが予想されます。

en: If native images have already been created by the ngen task or service, you will observe no difference in performance (but this snippet will at that point execute faster than otherwise).
ja: ネイティブイメージが ngen タスクやサービスによってすでに作成されている場合は、パフォーマンスに違いはありません (ただし、このスニペットはその時点で他の場合よりも高速に実行されます)。

en: PowerShell is used by every Windows Ansible module. This optimisation reduces the time PowerShell takes to start up, removing that overhead from every invocation.
ja: PowerShell はすべての Windows Ansible モジュールによって使用されます。この最適化により、PowerShell の起動時間を短縮し、呼び出しごとにそのオーバーヘッドを取り除きます。

en: This snippet uses `the native image generator, ngen <https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator#WhenToUse>`_ to pre-emptively create native images for the assemblies that PowerShell relies on.
ja: このスニペットは `ネイティブイメージジェネレーター ngen <https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator#WhenToUse>`_ を使用して、PowerShell が依存しているアセンブリーのネイティブイメージを事前に作成します。

en: Fix high-CPU-on-boot for VMs/cloud instances
ja: 仮想マシン/クラウドインスタンスの、システム起動時の高 CPU を修正

en: If you are creating golden images to spawn instances from, you can avoid a disruptive high CPU task near startup via `processing the ngen queue <https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator#native-image-service>`_ within your golden image creation, if you know the CPU types won't change between golden image build process and runtime.
ja: インスタンスを生成するためにゴールデンイメージを作成している場合は、ゴールデンイメージのビルドプロセスとランタイムの間で CPU タイプが変わらないことがわかっていれば、ゴールデンイメージの作成時に `ngen キューの処理 <https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator#native-image-service>`_ を使用することで、起動時に高い CPU タスクが発生するのを防ぐことができます。

en: Place the following near the end of your playbook, bearing in mind the factors that can cause native images to be invalidated (`see MSDN <https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator#native-images-and-jit-compilation>`_).
ja: Playbook の最後付近に以下を置き、ネイティブイメージが無効になる可能性のある要素に注意してください (`MSDN <https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator#native-images-and-jit-compilation>`_ を参照)。

en: Setting up a Windows Host
ja: Windows ホストのセットアップ

en: This document discusses the setup that is required before Ansible can communicate with a Microsoft Windows host.
ja: 本書では、Ansible が Microsoft Windows ホストと通信する前に必要なセットアップを説明します。

en: For Ansible to communicate to a Windows host and use Windows modules, the Windows host must meet these requirements:
ja: Ansible が Windows ホストと通信し、Windows モジュールを使用するためには、Windows ホストが以下の要件を満たす必要があります。

en: Ansible can generally manage Windows versions under current and extended support from Microsoft. Ansible can manage desktop OSs including Windows 7, 8.1, and 10, and server OSs including Windows Server 2008, 2008 R2, 2012, 2012 R2, 2016, and 2019.
ja: Ansible は、Microsoft の現行および拡張サポート下にある Windows バージョンを一般的に管理できます。Ansible は、Windows 7、8.1、および 10 を含むデスクトップ OS、およびWindows Server 2008、2008 R2、2012、2012 R2、2016、および 2019 を含むサーバー OS を管理できます。

en: Ansible requires PowerShell 3.0 or newer and at least .NET 4.0 to be installed on the Windows host.
ja: Ansible を利用するには、Windows ホストに PowerShell 3.0 以降と少なくとも .NET 4.0 がインストールされている必要があります。

en: A WinRM listener should be created and activated. More details for this can be found below.
ja: WinRM リスナーを作成し、有効にする必要があります。詳細は以下を参照してください。

en: While these are the base requirements for Ansible connectivity, some Ansible modules have additional requirements, such as a newer OS or PowerShell version. Please consult the module's documentation page to determine whether a host meets those requirements.
ja: これらは、Ansible 接続の基本的な要件ですが、Ansible モジュールの中には、新しい OS や PowerShell のバージョンなど、追加の要件があるものもあります。ホストがこれらの要件を満たしているかどうかは、モジュールのドキュメントページを参照してください。

en: Upgrading PowerShell and .NET Framework
ja: PowerShell および .NET Framework のアップグレード

en: Ansible requires PowerShell version 3.0 and .NET Framework 4.0 or newer to function on older operating systems like Server 2008 and Windows 7. The base image does not meet this requirement. You can use the `Upgrade-PowerShell.ps1 <https://github.com/jborean93/ansible-windows/blob/master/scripts/Upgrade-PowerShell.ps1>`_ script to update these.
ja: Ansible が Server 2008 や Windows 7 などの古いオペレーティングシステムで機能するためには、PowerShell の バージョン3.0 と .NET Framework 4.0 以降が必要です。ベースイメージは、この要件を満たしていません。`Upgrade-PowerShell.ps1 <https://github.com/jborean93/ansible-windows/blob/master/scripts/Upgrade-PowerShell.ps1>`_ スクリプトを使用してこれらを更新することができます。

en: This is an example of how to run this script from PowerShell:
ja: このスクリプトを PowerShell から実行する例を以下に示します。

en: Once completed, you will need to remove auto logon and set the execution policy back to the default (``Restricted `` for Windows clients, or ``RemoteSigned`` for Windows servers). You can do this with the following PowerShell commands:
ja: 完了したら、自動ログオンを解除して、実行ポリシーをデフォルト (Windows クライアントの場合は ``Restricted ``、Windows サーバーの場合は ``RemoteSigned``) に戻す必要があります。これには以下の PowerShell コマンドが必要です。

en: The script works by checking to see what programs need to be installed (such as .NET Framework 4.5.2) and what PowerShell version is required. If a reboot is required and the ``username`` and ``password`` parameters are set, the script will automatically reboot and logon when it comes back up from the reboot. The script will continue until no more actions are required and the PowerShell version matches the target version. If the ``username`` and ``password`` parameters are not set, the script will prompt the user to manually reboot and logon when required. When the user is next logged in, the script will continue where it left off and the process continues until no more actions are required.
ja: このスクリプトは、インストールが必要なプログラム (.NET Framework 4.5.2 など) や、必要な PowerShell バージョンを確認して動作します。再起動が必要で、``username`` パラメーターと ``password`` パラメーターが設定されている場合は、スクリプトが自動的に再起動し、再起動から復帰したときにログオンします。スクリプトは、アクションが不要になり、PowerShell バージョンがターゲットのバージョンと一致するまで続行されます。``username`` パラメーターおよび ``password`` パラメーターが設定されていない場合、スクリプトは必要に応じてユーザーに手動で再起動とログオンを促します。ユーザーが次にログインすると、スクリプトは前回の続きを実行し、アクションが必要なくなるまで処理を続けます。

en: If running on Server 2008, then SP2 must be installed. If running on Server 2008 R2 or Windows 7, then SP1 must be installed.
ja: Server 2008 で実行する場合は、SP2 がインストールされている必要があります。Server 2008 R2 または Windows 7 で実行している場合は SP1 をインストールする必要があります。

en: Windows Server 2008 can only install PowerShell 3.0; specifying a newer version will result in the script failing.
ja: Windows Server 2008 では PowerShell 3.0 しかインストールできないため、それより新しいバージョンを指定するとスクリプトが失敗します。

en: The ``username`` and ``password`` parameters are stored in plain text in the registry. Make sure the cleanup commands are run after the script finishes to ensure no credentials are still stored on the host.
ja: ``username`` と ``password`` のパラメーターは、レジストリーに平文で保存されます。スクリプトの終了後にクリーンアップコマンドを実行して、ホスト上に認証情報が保存されていないことを確認してください。

en: When running on PowerShell v3.0, there is a bug with the WinRM service that limits the amount of memory available to WinRM. Without this hotfix installed, Ansible will fail to execute certain commands on the Windows host. These hotfixes should be installed as part of the system bootstrapping or imaging process. The script `Install-WMF3Hotfix.ps1 <https://github.com/jborean93/ansible-windows/blob/master/scripts/Install-WMF3Hotfix.ps1>`_ can be used to install the hotfix on affected hosts.
ja: PowerShell v3.0 で実行する場合は、WinRM サービスのバグにより、WinRM で使用できるメモリー量が制限されるという問題がありました。この Hotfix をインストールしないと、Windows ホスト上で Ansible による特定のコマンドの実行に失敗します。これらの Hotfix は、システムのブートストラップまたはイメージングプロセスの一部としてインストールする必要があります。`Install-WMF3Hotfix.ps1 <https://github.com/jborean93/ansible-windows/blob/master/scripts/Install-WMF3Hotfix.ps1>`_ というスクリプトを使用すると、影響を受けるホストに Hotfix をインストールできます。

en: The following PowerShell command will install the hotfix:
ja: 以下の PowerShell コマンドはホットフィックスをインストールします。

en: For more details, please refer to the `Hotfix document <https://support.microsoft.com/en-us/help/2842230/out-of-memory-error-on-a-computer-that-has-a-customized-maxmemorypersh>`_ from Microsoft.
ja: 詳細は、Microsoft 社の `ホットフィックスのドキュメント <https://support.microsoft.com/en-us/help/2842230/out-of-memory-error-on-a-computer-that-has-a-customized-maxmemorypersh>`_ を参照してください。

en: WinRM Setup
ja: WinRM の設定

en: Once Powershell has been upgraded to at least version 3.0, the final step is for the WinRM service to be configured so that Ansible can connect to it. There are two main components of the WinRM service that governs how Ansible can interface with the Windows host: the ``listener`` and the ``service`` configuration settings.
ja: Powershell をバージョン 3.0 以降にアップグレードしたら、最後のステップとして、WinRM サービスを設定して Ansible が接続できるようにします。WinRM サービスには、Ansible が Windows ホストとどのように連携するかを決定する構成設定 ``listener`` と``service`` の 2 つの主要コンポーネントがあります。

en: Details about each component can be read below, but the script `ConfigureRemotingForAnsible.ps1 <https://github.com/ansible/ansible/blob/devel/examples/scripts/ConfigureRemotingForAnsible.ps1>`_ can be used to set up the basics. This script sets up both HTTP and HTTPS listeners with a self-signed certificate and enables the ``Basic`` authentication option on the service.
ja: 各コンポーネントの詳細については後述しますが、基本的な設定には`ConfigureRemotingForAnsible.ps1 <https://github.com/ansible/ansible/blob/devel/examples/scripts/ConfigureRemotingForAnsible.ps1>`_ スクリプトが使えます。このスクリプトは、自己署名証明書を用いて HTTP と HTTPS の両方のリスナーを設定し、サービスで ``Basic`` 認証オプションを有効にします。

en: To use this script, run the following in PowerShell:
ja: このスクリプトを使用するには、以下を PowerShell で実行します。

en: There are different switches and parameters (like ``-EnableCredSSP`` and ``-ForceNewSSLCert``) that can be set alongside this script. The documentation for these options are located at the top of the script itself.
ja: このスクリプトには、さまざまなスイッチやパラメーター (``-EnableCredSSP`` や ``-ForceNewSSLCert`` など) を設定することができます。これらのオプションのドキュメントは、スクリプト本体の上部にあります。

en: The ConfigureRemotingForAnsible.ps1 script is intended for training and development purposes only and should not be used in a production environment, since it enables settings (like ``Basic`` authentication) that can be inherently insecure.
ja: ConfigureRemotingForAnsible.ps1 スクリプトは、トレーニングと開発のみを目的としており、実稼働環境では使用しないでください。これは、本質的に安全でない可能性のある設定 (``Basic`` 認証など) を可能にするためです。

en: WinRM Listener
ja: WinRM リスナー

en: The WinRM services listens for requests on one or more ports. Each of these ports must have a listener created and configured.
ja: WinRM サービスは、1 つ以上のポートで要求をリッスンします。これらのポートごとにリスナーを作成し、設定する必要があります。

en: To view the current listeners that are running on the WinRM service, run the following command:
ja: WinRM サービスで実行している現在のリスナーを表示するには、次のコマンドを実行します。

en: This will output something like::
ja: これにより、以下のような出力が表示されます。

en: In the example above there are two listeners activated; one is listening on port 5985 over HTTP and the other is listening on port 5986 over HTTPS. Some of the key options that are useful to understand are:
ja: 上の例では、2 つのリスナーが有効になっています。1 つは HTTP でポート 5985 をリッスンしており、もう 1 つは HTTPS でポート 5986 をリッスンしています。理解しておくと便利なオプションをいくつか紹介します。

en: ``Transport``: Whether the listener is run over HTTP or HTTPS, it is recommended to use a listener over HTTPS as the data is encrypted without any further changes required.
ja: ``Transport``: リスナーが HTTP または HTTPS のどちらで実行されている場合でも、データはさらなる変更なしに暗号化されるため、HTTPS 経由でリスナーを使用することが推奨されます。

en: ``Port``: The port the listener runs on, by default it is ``5985`` for HTTP and ``5986`` for HTTPS. This port can be changed to whatever is required and corresponds to the host var ``ansible_port``.
ja: ``Port``: リスナーが実行するポート。デフォルトは、HTTP の場合は ``5985``、HTTPS の場合は ``5986`` です。このポートは、必要なものにそれぞれ変更でき、ホスト変数 ``ansible_port`` に対応することができます。

en: ``URLPrefix``: The URL prefix to listen on, by default it is ``wsman``. If this is changed, the host var ``ansible_winrm_path`` must be set to the same value.
ja: ``URLPrefix``: リッスンする URL プレフィックス。デフォルトは ``wsman`` です。これが変更された場合、ホスト変数 ``ansible_winrm_path`` は同じ値に設定する必要があります。

en: ``CertificateThumbprint``: If running over an HTTPS listener, this is the thumbprint of the certificate in the Windows Certificate Store that is used in the connection. To get the details of the certificate itself, run this command with the relevant certificate thumbprint in PowerShell::
ja: ``CertificateThumbprint``: HTTPS リスナーを介して実行する場合、これは接続に使用される Windows 証明書ストアの証明書のサムプリントです。証明書自体の詳細を取得するには、PowerShell で該当する証明書のサムプリントを指定して次のコマンドを実行します。

en: Setup WinRM Listener
ja: WinRM リスナーの設定

en: There are three ways to set up a WinRM listener:
ja: WinRM リスナーを設定するには、3 つの方法があります。

en: Using ``winrm quickconfig`` for HTTP or ``winrm quickconfig -transport:https`` for HTTPS. This is the easiest option to use when running outside of a domain environment and a simple listener is required. Unlike the other options, this process also has the added benefit of opening up the Firewall for the ports required and starts the WinRM service.
ja: HTTP には ``winrm quickconfig`` を、HTTPS には ``winrm quickconfig -transport:https`` を使用します。これは、ドメイン環境の外で動作し、シンプルなリスナーが必要な場合に、最も簡単に使用できるオプションです。他のオプションとは異なり、このプロセスには、必要なポートのためにファイアウォールを開き、WinRM サービスを開始するという利点があります。

en: Using Group Policy Objects. This is the best way to create a listener when the host is a member of a domain because the configuration is done automatically without any user input. For more information on group policy objects, see the `Group Policy Objects documentation <https://msdn.microsoft.com/en-us/library/aa374162(v=vs.85).aspx>`_.
ja: グループポリシーオブジェクトの使用。この方法は、ホストがドメインのメンバーである場合にリスナーを作成するのに最適な方法です。なぜなら、設定はユーザーの入力なしに自動的に行われるからです。グループポリシーオブジェクトの詳細は、`Group Policy Objects ドキュメント <https://msdn.microsoft.com/en-us/library/aa374162(v=vs.85).aspx>`_ を参照してください。

en: Using PowerShell to create the listener with a specific configuration. This can be done by running the following PowerShell commands:
ja: PowerShell を使用して、特定の設定でリスナーを作成します。これは、以下の PowerShell コマンドを実行することで可能になります。

en: To see the other options with this PowerShell cmdlet, see `New-WSManInstance <https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/new-wsmaninstance?view=powershell-5.1>`_.
ja: この PowerShell コマンドレッドをともなう他のオプションを表示するには、「`New-WSManInstance <https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/new-wsmaninstance?view=powershell-5.1>`_」を参照してください。

en: When creating an HTTPS listener, an existing certificate needs to be created and stored in the ``LocalMachine\My`` certificate store. Without a certificate being present in this store, most commands will fail.
ja: HTTPS リスナーを作成する際には、既存の証明書を作成し、``LocalMachine\My`` の証明書ストアに保存する必要があります。このストアに証明書が存在しないと、ほとんどのコマンドが失敗します。

en: Delete WinRM Listener
ja: WinRM リスナーの削除

en: To remove a WinRM listener::
ja: WinRM リスナーを削除するには、以下を実行します。

en: The ``Keys`` object is an array of strings, so it can contain different values. By default it contains a key for ``Transport=`` and ``Address=`` which correspond to the values from winrm enumerate winrm/config/Listeners.
ja: ``Keys`` オブジェクトは文字列の配列であるため、異なる値を含むことができます。デフォルトでは、winrm enumerate winrm/config/Listeners の値に対応す る``Transport=`` と``Address=`` のキーを含んでいます。

en: WinRM Service Options
ja: WinRM サービスオプション

en: There are a number of options that can be set to control the behavior of the WinRM service component, including authentication options and memory settings.
ja: WinRM サービスコンポーネントの動作を制御するように設定でき、認証オプションやメモリー設定など、複数のオプションを設定できます。

en: To get an output of the current service configuration options, run the following command:
ja: 現在のサービス設定オプションの出力を得るには、次のコマンドを実行します。

en: While many of these options should rarely be changed, a few can easily impact the operations over WinRM and are useful to understand. Some of the important options are:
ja: これらのオプションの多くはほとんど変更する必要はありませんが、いくつかのオプションは WinRM の操作に簡単に影響を与えるので、理解しておくと便利です。重要なオプションの一部を紹介します。

en: ``Service\AllowUnencrypted``: This option defines whether WinRM will allow traffic that is run over HTTP without message encryption. Message level encryption is only possible when ``ansible_winrm_transport`` is ``ntlm``, ``kerberos`` or ``credssp``. By default this is ``false`` and should only be set to ``true`` when debugging WinRM messages.
ja: ``Service\AllowUnencrypted``: このオプションは、メッセージを暗号化せずに HTTP で実行されるトラフィックを WinRM で許可するかどうかを定義します。メッセージレベルの暗号化は、``ansible_winrm_transport`` が ``ntlm``、``kerberos`` または ``credssp`` の場合にのみ可能です。デフォルトでは、これは ``false`` であり、WinRM メッセージをデバッグするときにのみ ``true`` に設定する必要があります。

en: ``Service\Auth\*``: These flags define what authentication options are allowed with the WinRM service. By default, ``Negotiate (NTLM)`` and ``Kerberos`` are enabled.
ja: ``Service\Auth\*``: これらのフラグは、WinRM サービスで許可される認証オプションを定義します。デフォルトでは、``Negotiate (NTLM)`` および ``Kerberos`` が有効になります。

en: ``Service\Auth\CbtHardeningLevel``: Specifies whether channel binding tokens are not verified (None), verified but not required (Relaxed), or verified and required (Strict). CBT is only used when connecting with NTLM or Kerberos over HTTPS.
ja: ``Service\Auth\CbtHardeningLevel``: チャンネルバインディングトークンを検証しない (None)、検証済みだが必要ない (Relaxed)、検証済みで必要 (Strict) のいずれかを指定します。CBT は、HTTPS の NTLM または Kerberos での接続時にのみ使用されます。

en: ``Service\CertificateThumbprint``: This is the thumbprint of the certificate used to encrypt the TLS channel used with CredSSP authentication. By default this is empty; a self-signed certificate is generated when the WinRM service starts and is used in the TLS process.
ja: ``Service\CertificateThumbprint``: これは、CredSSP 認証で使用される TLS チャンネルの暗号化に使用される証明書のサムプリントです。デフォルトでは、これは空です。自己署名証明書は、WinRM サービスの起動時に生成され、TLS プロセスで使用されます。

en: ``Winrs\MaxShellRunTime``: This is the maximum time, in milliseconds, that a remote command is allowed to execute.
ja: ``Winrs\MaxShellRunTime``: リモートコマンドの実行を許可する最大時間をミリ秒単位で指定します。

en: ``Winrs\MaxMemoryPerShellMB``: This is the maximum amount of memory allocated per shell, including the shell's child processes.
ja: ``Winrs\MaxMemoryPerShellMB``: シェルの子プロセスを含め、シェルごとに割り当てられるメモリーの最大量です。

en: To modify a setting under the ``Service`` key in PowerShell::
ja: PowerShell の ``Service`` キーで設定を変更するには、以下を実行します。

en: To modify a setting under the ``Winrs`` key in PowerShell::
ja: PowerShell の ``Winrs`` キーで設定を変更するには、以下を実行します。

en: If running in a domain environment, some of these options are set by GPO and cannot be changed on the host itself. When a key has been configured with GPO, it contains the text ``[Source="GPO"]`` next to the value.
ja: ドメイン環境で動作している場合、これらのオプションの一部は GPO によって設定され、ホスト自体では変更できません。GPO で設定されたキーには、値の横に ``[Source="GPO"]`` というテキストが表示されます。

en: Common WinRM Issues
ja: 一般的な WinRM の問題

en: Because WinRM has a wide range of configuration options, it can be difficult to setup and configure. Because of this complexity, issues that are shown by Ansible could in fact be issues with the host setup instead.
ja: WinRM にはさまざまな設定オプションがあるため、セットアップや設定が難しい場合があります。そのため、Ansible で表示される問題が、実際にはホストの設定の問題である可能性もあります。

en: One easy way to determine whether a problem is a host issue is to run the following command from another Windows host to connect to the target Windows host::
ja: 問題がホストの問題であるかどうかを判断する簡単な方法として、別の Windows ホストから次のコマンドを実行して、対象の Windows ホストに接続する方法があります。

en: If this fails, the issue is probably related to the WinRM setup. If it works, the issue may not be related to the WinRM setup; please continue reading for more troubleshooting suggestions.
ja: 失敗した場合は、WinRM の設定に問題があると思われます。成功した場合は、問題が WinRM の設定に関連していない可能性があるため、さらに詳しいトラブルシューティングの方法をご確認ください。

en: HTTP 401/Credentials Rejected
ja: HTTP 401/認証情報の拒否

en: A HTTP 401 error indicates the authentication process failed during the initial connection. Some things to check for this are:
ja: HTTP 401 エラーは、最初の接続時に認証プロセスが失敗したことを示します。これを確認するためのいくつかの項目があります。

en: Verify that the credentials are correct and set properly in your inventory with ``ansible_user`` and ``ansible_password``
ja: ``ansible_user`` および ``ansible_password`` を使用して、認証情報が正しく、インベントリーに適切に設定されていることを確認します。

en: Ensure that the user is a member of the local Administrators group or has been explicitly granted access (a connection test with the ``winrs`` command can be used to rule this out).
ja: ユーザーがローカルの Administrators グループのメンバーであるか、明示的にアクセスを許可されていることを確認してください (``winrs`` コマンドによる接続テストで除外できます)。

en: Make sure that the authentication option set by ``ansible_winrm_transport`` is enabled under ``Service\Auth\*``
ja: ``ansible_winrm_transport`` で設定した認証オプションが、``Service\Auth\*`` で有効になっていることを確認してください。

en: If running over HTTP and not HTTPS, use ``ntlm``, ``kerberos`` or ``credssp`` with ``ansible_winrm_message_encryption: auto`` to enable message encryption. If using another authentication option or if the installed pywinrm version cannot be upgraded, the ``Service\AllowUnencrypted`` can be set to ``true`` but this is only recommended for troubleshooting
ja: HTTPS ではなく HTTP で実行する場合は、``ntlm``、``kerberos``、または ``credssp`` と ``ansible_winrm_message_encryption: auto`` を使用してメッセージの暗号化を有効にしてください。他の認証オプションを使用している場合や、インストールされている pywinrm のバージョンをアップグレードできない場合は、``Service\AllowUnencrypted`` を``true`` に設定できますが、これはトラブルシューティングのためにのみ推奨されます。

en: Ensure the downstream packages ``pywinrm``, ``requests-ntlm``, ``requests-kerberos``, and/or ``requests-credssp`` are up to date using ``pip``.
ja: ダウンストリームパッケージである ``pywinrm``、``requests-ntlm``、``requests-kerberos``、または ``requests-credssp``、もしくはその組み合わせが ``pip`` を使用して最新の状態になっていることを確認します。

en: If using Kerberos authentication, ensure that ``Service\Auth\CbtHardeningLevel`` is not set to ``Strict``.
ja: Kerberos 認証を使用する場合は、``Service\Auth\CbtHardeningLevel`` が ``Strict`` に設定されていないことを確認してください。

en: When using Basic or Certificate authentication, make sure that the user is a local account and not a domain account. Domain accounts do not work with Basic and Certificate authentication.
ja: Basic 認証や Certificate 認証を使用する際は、ユーザーがドメインアカウントではなく、ローカルアカウントであることを確認してください。ドメインアカウントは、Basic 認証や Certificate 認証では機能しません。

en: These indicate an error has occurred with the WinRM service. Some things to check for include:
ja: これらは、WinRM サービスでエラーが発生したことを示しています。確認すべき点は以下の通りです。

en: Verify that the number of current open shells has not exceeded either ``WinRsMaxShellsPerUser`` or any of the other Winrs quotas haven't been exceeded.
ja: 現在のオープンシェルの数が ``WinRsMaxShellsPerUser`` のどちらかを超えていないか、または他の Winrs のクォータを超えていないかを確認してください。

en: Timeout Errors
ja: タイムアウトエラー

en: These usually indicate an error with the network connection where Ansible is unable to reach the host. Some things to check for include:
ja: これらは通常、Ansible がホストに到達できないネットワーク接続のエラーを示しています。チェック項目には以下が含まれます。

en: Make sure the firewall is not set to block the configured WinRM listener ports
ja: ファイアウォールが、設定された WinRM リスナーポートをブロックするように設定されていないことを確認します。

en: Ensure that a WinRM listener is enabled on the port and path set by the host vars
ja: WinRM リスナーが、ホストの変数によって設定されたポートおよびパスで有効になっていることを確認します。

en: Ensure that the ``winrm`` service is running on the Windows host and configured for automatic start
ja: Windows ホスト上で ``winrm`` サービスが稼動しており、自動起動するように設定されていることを確認する。

en: Connection Refused Errors
ja: 接続拒否エラー

en: These usually indicate an error when trying to communicate with the WinRM service on the host. Some things to check for:
ja: これらは通常、ホスト上の WinRM サービスと通信しようとする際にエラーを示します。いくつかのチェック項目があります。

en: Ensure that the WinRM service is up and running on the host. Use ``(Get-Service -Name winrm).Status`` to get the status of the service.
ja: ホスト上で WinRM サービスが稼働していることを確認します。``(Get-Service -Name winrm).Status`` を使用して、サービスのステータスを取得します。

en: Check that the host firewall is allowing traffic over the WinRM port. By default this is ``5985`` for HTTP and ``5986`` for HTTPS.
ja: ホスト側のファイアウォールが、WinRMポートへのトラフィックを許可していることを確認します。デフォルトでは、HTTP では ``5985``、HTTPS では ``5986`` となっています。

en: Sometimes an installer may restart the WinRM or HTTP service and cause this error. The best way to deal with this is to use ``win_psexec`` from another Windows host.
ja: インストーラーが WinRM や HTTP サービスを再起動してしまい、このエラーが発生することがあります。これに対処する最良の方法は、別の Windows ホストから ``win_psexec`` を使用します。

en: Failure to Load Builtin Modules
ja: 組み込みモジュールのロードに失敗

en: If powershell fails with an error message similar to ``The 'Out-String' command was found in the module 'Microsoft.PowerShell.Utility', but the module could not be loaded.`` then there could be a problem trying to access all the paths specified by the ``PSModulePath`` environment variable. A common cause of this issue is that the ``PSModulePath`` environment variable contains a UNC path to a file share and because of the double hop/credential delegation issue the Ansible process cannot access these folders. The way around this problems is to either:
ja: ``The 'Out-String' command was found in the module 'Microsoft.PowerShell.Utility', but the module could not be loaded.`` のようなエラーメッセージで powershell が失敗する場合は、``PSModulePath`` 環境変数で指定されたすべてのパスにアクセスしようとすると問題が発生する可能性があります。この問題の一般的な原因は、``PSModulePath`` 環境変数にファイル共有への UNC パスが含まれており、ダブルホップ/認証情報の委譲問題のために Ansible プロセスがこれらのディレクトリーにアクセスできないことです。この問題を回避するには、以下の方法があります。

en: Remove the UNC path from the ``PSModulePath`` environment variable, or
ja: ``PSModulePath`` 環境変数から UNC パスを削除します。

en: Use an authentication option that supports credential delegation like ``credssp`` or ``kerberos`` with credential delegation enabled
ja: 認証情報の委譲を有効にした ``credssp`` や ``kerberos`` のような、認証情報の委譲をサポートする認証オプションを使用します。

en: See `KB4076842 <https://support.microsoft.com/en-us/help/4076842>`_ for more information on this problem.
ja: この問題の詳細は、「`KB4076842 <https://support.microsoft.com/en-us/help/4076842>`_」を参照してください。

en: Windows SSH Setup
ja: Windows SSH の設定

en: Ansible 2.8 has added an experimental SSH connection for Windows managed nodes.
ja: Ansible 2.8 では、Windows 管理ノードの実験的な SSH 接続が追加されました。

en: Use this feature at your own risk! Using SSH with Windows is experimental, the implementation may make backwards incompatible changes in feature releases. The server side components can be unreliable depending on the version that is installed.
ja: この機能はご自身の責任でお使いください。Windows での SSH の使用は実験的なものであり、実装は機能リリースにおいて後方互換性のない変更を行う可能性があります。また、サーバー側のコンポーネントは、インストールされているバージョンによっては信頼性に欠けることがあります。

en: Installing Win32-OpenSSH
ja: Win32-OpenSSH のインストール

en: The first step to using SSH with Windows is to install the `Win32-OpenSSH <https://github.com/PowerShell/Win32-OpenSSH>`_ service on the Windows host. Microsoft offers a way to install ``Win32-OpenSSH`` through a Windows capability but currently the version that is installed through this process is too old to work with Ansible. To install ``Win32-OpenSSH`` for use with Ansible, select one of these three installation options:
ja: Windows で SSH を利用するための最初のステップは、Windows ホストに `Win32-OpenSSH <https://github.com/PowerShell/Win32-OpenSSH>`_ サービスをインストールすることです。Microsoft 社では，Windows の機能を利用して ``Win32-OpenSSH`` をインストールする方法を提供していますが、現在、この方法でインストールされるバージョンは，Ansible で動作させるには古すぎます．Ansible で使用するために ``Win32-OpenSSH`` をインストールするには、以下の 3 つのインストールオプションのいずれかを選択します。

en: Manually install the service, following the `install instructions <https://github.com/PowerShell/Win32-OpenSSH/wiki/Install-Win32-OpenSSH>`_ from Microsoft.
ja: Microsoft 社が提供する `インストール手順 <https://github.com/PowerShell/Win32-OpenSSH/wiki/Install-Win32-OpenSSH>`_ に従って、サービスを手動でインストールしてください。

en: Install the `openssh <https://chocolatey.org/packages/openssh>`_ package using Chocolatey::
ja: Chocolatey を使用して `openssh <https://chocolatey.org/packages/openssh>`_ パッケージをインストールします。

en: Use ``win_chocolatey`` to install the service::
ja: ``win_chocolatey`` を使用してサービスをインストールします。

en: Use an existing Ansible Galaxy role like `jborean93.win_openssh <https://galaxy.ansible.com/jborean93/win_openssh>`_::
ja: `jborean93.win_openssh <https://galaxy.ansible.com/jborean93/win_openssh>`_ などの既存の Ansible Galaxy ロールを使用します。

en: ``Win32-OpenSSH`` is still a beta product and is constantly being updated to include new features and bugfixes. If you are using SSH as a connection option for Windows, it is highly recommend you install the latest release from one of the 3 methods above.
ja: ``Win32-OpenSSH`` は未だベータ版の製品であり、新機能やバグ修正を含めて常に更新されています。Windows で SSH 接続をご利用の方は、上記 3 つの方法から最新版をインストールすることが強く推奨します。

en: Configuring the Win32-OpenSSH shell
ja: Win32-OpenSSH シェルの設定

en: By default ``Win32-OpenSSH`` will use ``cmd.exe`` as a shell. To configure a different shell, use an Ansible task to define the registry setting::
ja: デフォルトでは、``Win32-OpenSSH`` は ``cmd.exe`` をシェルとして使用します。別のシェルを設定するには、Ansible タスクを使用して、レジストリー設定を定義します。

en: Win32-OpenSSH authentication with Windows is similar to SSH authentication on Unix/Linux hosts. You can use a plaintext password or SSH public key authentication, add public keys to an ``authorized_key`` file in the ``.ssh`` folder of the user's profile directory, and configure the service using the ``sshd_config`` file used by the SSH service as you would on a Unix/Linux host.
ja: Windows での Win32-OpenSSH 認証は、Unix/Linux ホストでの SSH 認証に似ています。平文のパスワードまたは SSH 公開鍵認証を使用し、公開鍵をユーザーのプロファイルディレクトリーの ``.ssh`` ディレクトリーにある ``authorized_key`` ファイルに追加し、Unix/Linux ホストと同様に SSH サービスで使用される ``sshd_config`` ファイルを使用してサービスを設定することができます。

en: When using SSH key authentication with Ansible, the remote session won't have access to the user's credentials and will fail when attempting to access a network resource. This is also known as the double-hop or credential delegation issue. There are two ways to work around this issue:
ja: Ansible で SSH 鍵認証を使用する場合は、リモートセッションがユーザーの認証情報にアクセスできず、ネットワークリソースにアクセスしようとすると失敗することがあります。これは、ダブルホップや認証情報の委譲の問題としても知られています。この問題を回避するには 2 つの方法があります。

en: Use plaintext password auth by setting ``ansible_password``
ja: ``ansible_password`` を設定して平文テキストのパスワード認証を使用する

en: Use ``become`` on the task with the credentials of the user that needs access to the remote resource
ja: リモートリソースへのアクセスを必要とするユーザーの認証情報を使用して、タスクで ``become`` を使用する

en: Configuring Ansible for SSH on Windows
ja: Windows で SSH 用に Ansible の設定

en: To configure Ansible to use SSH for Windows hosts, you must set two connection variables:
ja: Ansible が Windows ホストに SSH を使用するように設定するには、接続変数を 2 つ設定する必要があります。

en: set ``ansible_connection`` to ``ssh``
ja: ``ansible_connection`` を ``ssh`` に設定します。

en: set ``ansible_shell_type`` to ``cmd`` or ``powershell``
ja: ``ansible_shell_type`` を ``cmd`` または ``powershell`` に設定する

en: The ``ansible_shell_type`` variable should reflect the ``DefaultShell`` configured on the Windows host. Set to ``cmd`` for the default shell or set to ``powershell`` if the ``DefaultShell`` has been changed to PowerShell.
ja: ``ansible_shell_type`` 変数には、Windows ホストで設定されている``DefaultShell`` を反映させる必要があります。デフォルトのシェルの場合は ``cmd`` に、``DefaultShell`` が PowerShell に変更している場合は ``powershell`` に設定します。

en: Known issues with SSH on Windows
ja: Windows での SSH に関する既知の問題

en: Using SSH with Windows is experimental, and we expect to uncover more issues. Here are the known ones:
ja: Windows での SSH の使用は実験的なものであり、より多くの問題が発見されることを期待しています。ここでは、既知のものを紹介します。

en: Win32-OpenSSH versions older than ``v7.9.0.0p1-Beta`` do not work when ``powershell`` is the shell type
ja: ``powershell`` がシェルタイプの場合は、``v7.9.0.0p1-Beta`` よりも古い Win32-OpenSSH バージョンは機能しません。

en: While SCP should work, SFTP is the recommended SSH file transfer mechanism to use when copying or fetching a file
ja: SCP も有効ですが、SFTP は、ファイルのコピーまたは取得時に使用する、推奨される SSH ファイル転送メカニズムです。

en: Using Ansible and Windows
ja: Ansible と Windows の使用

en: When using Ansible to manage Windows, many of the syntax and rules that apply for Unix/Linux hosts also apply to Windows, but there are still some differences when it comes to components like path separators and OS-specific tasks. This document covers details specific to using Ansible for Windows.
ja: Ansible を使用して Windows を管理する場合は、Unix/Linux ホストに適用される構文やルールの多くが Windows にも適用されますが、パスセパレーターや OS 固有のタスクなどのコンポーネントに関しては、若干の違いがあります。このドキュメントでは、Ansible を Windows で使用する際の詳細について説明します。

en: Use Cases
ja: ユースケース

en: Ansible can be used to orchestrate a multitude of tasks on Windows servers. Below are some examples and info about common tasks.
ja: Ansible は、Windows サーバーにある多数のタスクを調整するために使用できます。以下は、一般的なタスクに関する例と情報です。

en: Installing Software
ja: ソフトウェアのインストール

en: There are three main ways that Ansible can be used to install software:
ja: Ansible を使用してソフトウェアをインストールできる主な方法は 3 つあります。

en: Using the ``win_chocolatey`` module. This sources the program data from the default public `Chocolatey <https://chocolatey.org/>`_ repository. Internal repositories can be used instead by setting the ``source`` option.
ja: ``win_chocolatey`` モジュールを使用。このモジュールは、デフォルトのパブリックな `Chocolatey <https://chocolatey.org/>`_ リポジトリーからプログラムデータを調達します。``source`` オプションを設定することで、代わりに内部リポジトリーを使用することができます。

en: Using the ``win_package`` module. This installs software using an MSI or .exe installer from a local/network path or URL.
ja: ``win_package`` モジュールを使用します。これは、ローカル/ネットワークパスまたは URL から MSI または .exe インストーラーを使用してソフトウェアをインストールします。

en: Using the ``win_command`` or ``win_shell`` module to run an installer manually.
ja: ``win_command`` モジュールまたは ``win_shell`` モジュールを使用して手動でインストーラーを実行する。

en: The ``win_chocolatey`` module is recommended since it has the most complete logic for checking to see if a package has already been installed and is up-to-date.
ja: ``win_chocolatey`` モジュールは、パッケージがすでにインストールされていて最新かどうかを確認するための最も完全なロジックを備えているため、このモジュールを使用することが推奨されます。

en: Below are some examples of using all three options to install 7-Zip:
ja: 以下は、3 つのすべてのオプションを使用して 7-Zip をインストールするいくつかの例です。

en: Some installers like Microsoft Office or SQL Server require credential delegation or access to components restricted by WinRM. The best method to bypass these issues is to use ``become`` with the task. With ``become``, Ansible will run the installer as if it were run interactively on the host.
ja: Microsoft Office や SQL Server などの一部のインストーラーは、認証情報の委譲や WinRM で制限されたコンポーネントへのアクセスを必要とします。これらの問題を回避するための最良の方法は、タスクに ``become`` を使用することです。``become`` を使用すると、Ansible はあたかもホスト上で対話的に実行されているかのようにインストーラを実行します。

en: Many installers do not properly pass back error information over WinRM. In these cases, if the install has been  verified to work locally the recommended method is to use become.
ja: 多くのインストーラーは、WinRM を介してエラー情報を適切に返しません。このような場合には、ローカルでの動作が確認されている場合には become を使用することをお勧めします。

en: Some installers restart the WinRM or HTTP services, or cause them to become temporarily unavailable, making Ansible assume the system is unreachable.
ja: 一部のインストーラーは、WinRM または HTTP サービスを再起動したり、一時的に利用できなくなったりするため、システムが到達不能であると Ansible により想定されます。

en: Installing Updates
ja: 更新のインストール

en: The ``win_updates`` and ``win_hotfix`` modules can be used to install updates or hotfixes on a host. The module ``win_updates`` is used to install multiple updates by category, while ``win_hotfix`` can be used to install a single update or hotfix file that has been downloaded locally.
ja: ``win_updates`` モジュールおよび ``win_hotfix`` モジュールを使用すると、ホストにアップデートや Hotfix をインストールできます。モジュール ``win_updates`` はカテゴリー別に複数のアップデートをインストールするために使用され、``win_hotfix`` はローカルにダウンロードされた単一の更新または Hotfix ファイルをインストールするために使用されます。

en: The ``win_hotfix`` module has a requirement that the DISM PowerShell cmdlets are present. These cmdlets were only added by default on Windows Server 2012 and newer and must be installed on older Windows hosts.
ja: ``win_hotfix`` モジュールには、DISM PowerShell コマンドレットが存在するという要件があります。これらのコマンドレットは、Windows Server 2012 以降でのみデフォルトで追加されており、それ以前の Windows ホストではインストールする必要があります。

en: The following example shows how ``win_updates`` can be used:
ja: 次の例は、``win_updates`` の使用方法を示しています。

en: The following example show how ``win_hotfix`` can be used to install a single update or hotfix:
ja: 以下の例では、``win_hotfix`` を使用して単一のアップデートまたは Hotfix をインストールする方法を示しています。

en: Set Up Users and Groups
ja: ユーザーおよびグループの設定

en: Ansible can be used to create Windows users and groups both locally and on a domain.
ja: Ansible を使用して、ローカルとドメインの両方で Windows ユーザーおよびグループを作成できます。

en: Local
ja: ローカル

en: The modules ``win_user``, ``win_group`` and ``win_group_membership`` manage Windows users, groups and group memberships locally.
ja: ``win_user`` モジュール、``win_group`` モジュール、および ``win_group_membership`` モジュールは、Windows のユーザー、グループ、およびグループのメンバーシップをローカルに管理します。

en: The following is an example of creating local accounts and groups that can access a folder on the same host:
ja: 以下は、同じホスト上のディレクトリーにアクセスできるローカルアカウントとグループを作成する例を示します。

en: Domain
ja: ドメイン

en: The modules ``win_domain_user`` and ``win_domain_group`` manages users and groups in a domain. The below is an example of ensuring a batch of domain users are created:
ja: ``win_domain_user`` モジュールおよび ``win_domain_group`` モジュールは、ドメインのユーザーおよびグループを管理します。以下は、ドメインユーザーのバッチを確実に作成する例です。

en: Running Commands
ja: コマンドの実行

en: In cases where there is no appropriate module available for a task, a command or script can be run using the ``win_shell``, ``win_command``, ``raw``, and ``script`` modules.
ja: タスクに適したモジュールがない場合は、``win_shell`` モジュール、``win_command`` モジュール、``raw`` モジュール、および ``script`` モジュールを使用してコマンドやスクリプトを実行できます。

en: The ``raw`` module simply executes a Powershell command remotely. Since ``raw`` has none of the wrappers that Ansible typically uses, ``become``, ``async`` and environment variables do not work.
ja: ``raw`` モジュールは、Powershell コマンドをリモートで実行するだけです。``raw`` は、Ansible が通常使用するラッパーを一切使用していないため、``become``、``async`` および環境変数は動作しません。

en: The ``script`` module executes a script from the Ansible controller on one or more Windows hosts. Like ``raw``, ``script`` currently does not support ``become``, ``async``, or environment variables.
ja: ``script`` モジュールは、Ansible コントローラーからのスクリプトを 1 つまたは複数の Windows ホスト上で実行します。``raw`` と同様に、``script`` は現在、``become``、``async``、または環境変数をサポートしていません。

en: The ``win_command`` module is used to execute a command which is either an executable or batch file, while the ``win_shell`` module is used to execute commands within a shell.
ja: ``win_command`` モジュールは、実行ファイルまたはバッチファイルであるコマンドを実行するために使用され、``win_shell`` モジュールは、シェル内のコマンドを実行するために使用されます。

en: Choosing Command or Shell
ja: コマンドまたはシェルの選択

en: The ``win_shell`` and ``win_command`` modules can both be used to execute a command or commands. The ``win_shell`` module is run within a shell-like process like ``PowerShell`` or ``cmd``, so it has access to shell operators like ``<``, ``>``, ``|``, ``;``, ``&&``, and ``||``. Multi-lined commands can also be run in ``win_shell``.
ja: ``win_shell`` モジュールおよび``win_command`` モジュールは、どちらもコマンドの実行に使用できます。``win_shell`` モジュールは ``PowerShell`` や``cmd`` のようなシェルライクなプロセス内で実行されるため、``<``、``>``、``|``、``;``、``&&``、``||`` のようなシェル演算子にアクセスできます。``win_shell`` では、複数行のコマンドも実行できます。

en: The ``win_command`` module simply runs a process outside of a shell. It can still run a shell command like ``mkdir`` or ``New-Item`` by passing the shell commands to a shell executable like ``cmd.exe`` or ``PowerShell.exe``.
ja: ``win_command`` モジュールは、シェルの外部でプロセスを実行するだけです。``cmd.exe`` や ``PowerShell.exe`` などのシェル実行ファイルに、``mkdir`` や ``New-Item`` などのシェルコマンドを渡してシェルコマンドを実行できます。

en: Here are some examples of using ``win_command`` and ``win_shell``:
ja: 以下は、``win_command`` と``win_shell`` を使用した例です。

en: Some commands like ``mkdir``, ``del``, and ``copy`` only exist in the CMD shell. To run them with ``win_command`` they must be prefixed with ``cmd.exe /c``.
ja: ``mkdir``、``del``、``copy`` などの一部のコマンドは、CMD シェルにのみ存在します。``win_command`` でそれらを実行するには、``cmd.exe /c`` プレフィックスを付ける必要があります。

en: Argument Rules
ja: 引数のルール

en: When running a command through ``win_command``, the standard Windows argument rules apply:
ja: ``win_command`` を通じてコマンドを実行する際には、Windows の標準的な引数ルールが適用されます。

en: Each argument is delimited by a white space, which can either be a space or a tab.
ja: 各引数は、空白またはタブのいずれかである空白で区切られます。

en: An argument can be surrounded by double quotes ``"``. Anything inside these quotes is interpreted as a single argument even if it contains whitespace.
ja: 引数は二重引用符 ``"`` で囲むことができます。これらの引用符の内側には、空白が含まれていても、1 つの引数として解釈されます。

en: A double quote preceded by a backslash ``\`` is interpreted as just a double quote ``"`` and not as an argument delimiter.
ja: バックスラッシュ ``\`` が前に付いた二重引用符は、引数区切り文字ではなく二重引用符 ``"`` として解釈されます。

en: Backslashes are interpreted literally unless it immediately precedes double quotes; for example ``\`` == ``\`` and ``\"`` == ``"``
ja: バックスラッシュは、二重引用符の直前にない限り、文字通りに解釈されます (例: ``\`` ==``\`` および ``\"`` == ``"``)。

en: If an even number of backslashes is followed by a double quote, one backslash is used in the argument for every pair, and the double quote is used as a string delimiter for the argument.
ja: 偶数個のバックスラッシュの後に二重引用符が続く場合は、すべてのペアの引数で 1 つのバックスラッシュが使用され、二重引用符が引数の文字列区切り文字として使用されます。

en: If an odd number of backslashes is followed by a double quote, one backslash is used in the argument for every pair, and the double quote is escaped and made a literal double quote in the argument.
ja: 奇数個のバックスラッシュの後に二重引用符が続く場合、引数ではペアごとに 1 つのバックスラッシュが使用され、二重引用符はエスケープされて引数のリテラル二重引用符となります。

en: With those rules in mind, here are some examples of quoting:
ja: これらのルールを念頭に置いて、引用の例をいくつか示します。

en: For more information, see `escaping arguments <https://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx>`_.
ja: 詳細情報は、「`escaping arguments <https://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx>`_」を参照してください。

en: Creating and Running a Scheduled Task
ja: スケジュールされたタスクの作成および実行

en: WinRM has some restrictions in place that cause errors when running certain commands. One way to bypass these restrictions is to run a command through a scheduled task. A scheduled task is a Windows component that provides the ability to run an executable on a schedule and under a different account.
ja: WinRM には、特定のコマンドを実行したときにエラーが発生するような制限が設けられています。これらの制限を回避する方法の 1 つとして、スケジュールされたタスクを使用してコマンドを実行する方法があります。スケジュールされたタスクとは、実行ファイルをスケジュールに沿って、別のアカウントで実行する機能を提供する Windows コンポーネントです。

en: Ansible version 2.5 added modules that make it easier to work with scheduled tasks in Windows. The following is an example of running a script as a scheduled task that deletes itself after running:
ja: Ansible バージョン 2.5 では、Windows でのスケジュールタスクの操作を容易にするモジュールが追加されました。以下は、実行後に自分自身を削除するスクリプトをスケジュールタスクとして実行する例です。

en: The modules used in the above example were updated/added in Ansible version 2.5.
ja: 上記の例で使用されているモジュールは、Ansible バージョン 2.5 で更新または追加されたものです。

en: Path Formatting for Windows
ja: Windows のパスのフォーマット

en: Windows differs from a traditional POSIX operating system in many ways. One of the major changes is the shift from ``/`` as the path separator to ``\``. This can cause major issues with how playbooks are written, since ``\`` is often used as an escape character on POSIX systems.
ja: Windows は、従来の POSIX オペレーティングシステムとは多くの点で異なります。主な変更点のひとつは、パスの区切り文字が ``/`` から ``\`` になったことです。POSIX システムでは、``\`` がしばしばエスケープ文字として使用されるため、これは Playbook の記述方法に重大な問題を引き起こす可能性があります。

en: Ansible allows two different styles of syntax; each deals with path separators for Windows differently:
ja: Ansible では、2 つの異なるスタイルの構文を使用できます。それぞれ Windows のパスセパレーターの扱いが異なります。

en: YAML Style
ja: YAML スタイル

en: When using the YAML syntax for tasks, the rules are well-defined by the YAML standard:
ja: タスクに YAML 構文を使用する場合、そのルールは YAML 規格によって明確に定義されています。

en: When using a normal string (without quotes), YAML will not consider the backslash an escape character.
ja: 通常の文字列 (引用符なし) を使用する場合、YAML はバックスラッシュをエスケープ文字とはみなしません。

en: When using single quotes ``'``, YAML will not consider the backslash an escape character.
ja: 一重引用符 ``'`` を使用する場合、YAML はバックスラッシュをエスケープ文字とはみなしません。

en: When using double quotes ``"``, the backslash is considered an escape character and needs to escaped with another backslash.
ja: 二重引用符 ``"`` を使用する場合、バックスラッシュはエスケープ文字と見なされ、別のバックスラッシュでエスケープする必要があります。

en: You should only quote strings when it is absolutely necessary or required by YAML, and then use single quotes.
ja: 文字列を引用するのは、絶対に必要な場合や YAML で要求される場合のみとし、その場合は一重引用符を使用します。

en: The YAML specification considers the following `escape sequences <https://yaml.org/spec/current.html#id2517668>`_:
ja: YAML 仕様は、以下の `エスケープシーケンス <https://yaml.org/spec/current.html#id2517668>`_ を考慮します。

en: ``\0``, ``\\``, ``\"``, ``\_``, ``\a``, ``\b``, ``\e``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``, ``\L``, ``\N`` and ``\P`` -- Single character escape
ja: ``\0``、``\\``、``\"``、``\_``、``\a``、``\b``、``\e``、``\f``、``\n``、``\r``、``\t``、``\v``、``\L``、``\N``、および ``\P`` -- 一文字のエスケープ

en: ``<TAB>``, ``<SPACE>``, ``<NBSP>``, ``<LNSP>``, ``<PSP>`` -- Special characters
ja: ``<TAB>``、``<SPACE>``、``<NBSP>``、``<LNSP>``、``<PSP>`` -- 特殊文字

en: ``\x..`` -- 2-digit hex escape
ja: ``\x..`` -- 2 桁の 16 進エスケープ

en: ``\u....`` -- 4-digit hex escape
ja: ``\u....`` -- 4 桁の 16 進エスケープ

en: ``\U........`` -- 8-digit hex escape
ja: ``\U........`` -- 8 桁の 16 進エスケープ

en: Here are some examples on how to write Windows paths::
ja: Windows パスの記述方法の例を次に示します。

en: This is an example which will fail:
ja: これは失敗する例です。

en: This example shows the use of single quotes when they are required::
ja: この例は、必要な場合の一重引用符の使用を示しています。

en: Legacy key=value Style
ja: 従来の key=value スタイル

en: The legacy ``key=value`` syntax is used on the command line for ad hoc commands, or inside playbooks. The use of this style is discouraged within playbooks because backslash characters need to be escaped, making playbooks harder to read. The legacy syntax depends on the specific implementation in Ansible, and quoting (both single and double) does not have any effect on how it is parsed by Ansible.
ja: 従来の ``key=value`` の構文は、コマンドラインでのアドホックなコマンドや Playbook 内で使用されます。バックスラッシュ文字をエスケープする必要があり、Playbook が読みづらくなるため、Playbook 内ではこのスタイルの使用は推奨されません。レガシー構文は、Ansible の特定の実装に依存しており、引用符 (単一および二重) は、Ansible での解析方法には影響しません。

en: The Ansible key=value parser parse_kv() considers the following escape sequences:
ja: Ansible の key=value パーサー parse_kv() は、以下のエスケープシーケンスを考慮します。

en: ``\``, ``'``, ``"``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t`` and ``\v`` -- Single character escape
ja: ``\``、``'``、``"``、``\a``、``\b``、``\f``、``\n``、``\r``、``\t``、``\v`` -- 一文字のエスケープ

en: ``\N{...}`` -- Unicode character by name
ja: ``\N{...}`` -- 名前による Unicode 文字

en: This means that the backslash is an escape character for some sequences, and it is usually safer to escape a backslash when in this form.
ja: これは、バックスラッシュがいくつかのシーケンスのエスケープ文字になっていることを意味しており、通常、この形式の場合はバックスラッシュをエスケープする方が安全です。

en: Here are some examples of using Windows paths with the key=value style:
ja: key=value スタイルで Windows パスを使用する例を次に示します。

en: The failing examples don't fail outright but will substitute ``\t`` with the ``<TAB>`` character resulting in ``tempdir`` being ``C:\Windows<TAB>emp``.
ja: 失敗した例では、完全に失敗するわけではありませんが、``\t`` を ``<TAB>`` の文字で置き換えて、``tempdir`` を ``C:\Windows<TAB>emp`` にします。

en: Limitations
ja: 制限事項

en: Some things you cannot do with Ansible and Windows are:
ja: ここでは、Ansible および Windows でできないことを説明します。

en: Upgrade PowerShell
ja: PowerShell のアップグレード

en: Interact with the WinRM listeners
ja: WinRM リスナーとの対話

en: Because WinRM is reliant on the services being online and running during normal operations, you cannot upgrade PowerShell or interact with WinRM listeners with Ansible. Both of these actions will cause the connection to fail. This can technically be avoided by using ``async`` or a scheduled task, but those methods are fragile if the process it runs breaks the underlying connection Ansible uses, and are best left to the bootstrapping process or before an image is created.
ja: WinRM は、通常の運用時にサービスがオンラインで稼働していることに依存しているため、PowerShell をアップグレードしたり、Ansible で WinRM リスナーと対話したりすることはできません。これらのアクションはいずれも、接続の失敗を引き起こします。これは、技術的には ``async`` やスケジュールされたタスクを使用することで回避できますが、これらの方法は、実行するプロセスによって Ansible が使用する基礎的な接続が壊れると脆弱になるため、ブートストラッププロセスやイメージが作成される前に任せるのが最適です。

en: Developing Windows Modules
ja: Windows モジュールの開発

en: Because Ansible modules for Windows are written in PowerShell, the development guides for Windows modules differ substantially from those for standard standard modules. Please see :ref:`developing_modules_general_windows` for more information.
ja: Windows 用の Ansible モジュールは PowerShell で書かれているため、Windows モジュールの開発ガイドは標準規格のモジュールの開発ガイドとは大きく異なります。詳細は、「:ref:`developing_modules_general_windows`」を参照してください。

en: Windows Remote Management
ja: Windows リモート管理

en: Unlike Linux/Unix hosts, which use SSH by default, Windows hosts are configured with WinRM. This topic covers how to configure and use WinRM with Ansible.
ja: デフォルトで SSH を使用する Linux/Unix ホストとは異なり、Windows ホストは WinRM で設定されています。このトピックでは、Ansible で WinRM を設定し、使用する方法を説明します。

en: What is WinRM?
ja: WinRM とは

en: WinRM is a management protocol used by Windows to remotely communicate with another server. It is a SOAP-based protocol that communicates over HTTP/HTTPS, and is included in all recent Windows operating systems. Since Windows Server 2012, WinRM has been enabled by default, but in most cases extra configuration is required to use WinRM with Ansible.
ja: WinRM は、Windows が別のサーバーとリモートで通信する際に使用する管理プロトコルです。WinRM は、HTTP/HTTPS で通信する SOA Pベースのプロトコルで、最近のすべての Windows OS に搭載されています。Windows Server 2012 以降、WinRM はデフォルトで有効になっていますが、ほとんどの場合、Ansible で WinRM を使用するには追加の設定が必要です。

en: Ansible uses the `pywinrm <https://github.com/diyan/pywinrm>`_ package to communicate with Windows servers over WinRM. It is not installed by default with the Ansible package, but can be installed by running the following:
ja: Ansible は `pywinrm <https://github.com/diyan/pywinrm>`_ パッケージを使用して、WinRM を介して Windows サーバーと通信します。デフォルトでは Ansible パッケージとともにインストールされませんが、以下を実行することでインストールできます。

en: on distributions with multiple python versions, use pip2 or pip2.x, where x matches the python minor version Ansible is running under.
ja: 複数の python バージョンがあるディストリビューションでは、pip2 または pip2.x を使用します。x は、Ansible を実行している python マイナーバージョンと一致します。

en: Using the ``winrm`` or ``psrp`` connection plugins in Ansible on MacOS in the latest releases typically fail. This is a known problem that occurs deep within the Python stack and cannot be changed by Ansible. The only workaround today is to set the environment variable ``no_proxy=*`` and avoid using Kerberos auth.
ja: 最新リリースの MacOS 上の Ansible で、``winrm`` または``psrp`` 接続プラグインを使用すると、通常は失敗します。これは、Python スタックの奥深くで発生する既知の問題であり、Ansible では変更できません。現在の唯一の回避策は、環境変数 ``no_proxy=*`` を設定し、Kerberos 認証を使用しないようにしてください。

en: Authentication Options
ja: 認証オプション

en: When connecting to a Windows host, there are several different options that can be used when authenticating with an account. The authentication type may be set on inventory hosts or groups with the ``ansible_winrm_transport`` variable.
ja: Windows ホストに接続する際、アカウントで認証する際に使用できるいくつかの異なるオプションがあります。認証タイプは、インベントリーのホストまたはグループに ``ansible_winrm_transport`` 変数で設定できます。

en: The following matrix is a high level overview of the options:
ja: 以下のマトリックスは、オプションの概要を示しています。

en: Option
ja: オプション

en: Local Accounts
ja: ローカルアカウント

en: Active Directory Accounts
ja: Active Directory アカウント

en: Credential Delegation
ja: 認証情報の委譲

en: HTTP Encryption
ja: HTTP 暗号化

en: Basic
ja: 基本

en: Yes
ja: 可

en: No
ja: 不可

en: Certificate
ja: 証明書

en: Basic authentication is one of the simplest authentication options to use, but is also the most insecure. This is because the username and password are simply base64 encoded, and if a secure channel is not in use (eg, HTTPS) then it can be decoded by anyone. Basic authentication can only be used for local accounts (not domain accounts).
ja: Basic 認証は、最もシンプルな認証方法の 1 つですが、安全性が最も低くなります。これは、ユーザー名とパスワードが単純に Base64 エンコードされているためで、安全なチャンネル (例: HTTPS) が使用されていない場合は、誰でも解読することができます。Basic 認証は、ローカルアカウントにのみ使用することができます (ドメインアカウントには使用できません)。

en: The following example shows host vars configured for basic authentication:
ja: 以下の例は、基本認証に設定されているホスト変数を示しています。

en: Basic authentication is not enabled by default on a Windows host but can be enabled by running the following in PowerShell::
ja: Basic 認証は、Windows ホストではデフォルトでは有効になっていませんが、PowerShell で以下を実行することで有効にすることができます。

en: Certificate authentication uses certificates as keys similar to SSH key pairs, but the file format and key generation process is different.
ja: 証明書認証は、SSH キーペアに似た鍵として証明書を使用しますが、ファイル形式と鍵の生成プロセスは異なります。

en: The following example shows host vars configured for certificate authentication:
ja: 以下の例では、証明書認証に設定されているホスト変数を示しています。

en: Certificate authentication is not enabled by default on a Windows host but can be enabled by running the following in PowerShell::
ja: 証明書認証は、Windows ホストではデフォルトでは有効になっていませんが、PowerShell で以下を実行することで有効にすることができます。

en: Encrypted private keys cannot be used as the urllib3 library that is used by Ansible for WinRM does not support this functionality.
ja: 暗号化された秘密鍵は、WinRM 向けに Ansible が使用する urllib3 ライブラリーとしては使用できません。この機能をサポートしません。

en: Generate a Certificate
ja: 証明書の生成

en: A certificate must be generated before it can be mapped to a local user. This can be done using one of the following methods:
ja: 証明書をローカルユーザーにマッピングする前に、証明書を生成する必要があります。これは、以下のいずれかの方法で行うことができます。

en: PowerShell, using the ``New-SelfSignedCertificate`` cmdlet
ja: ``New-SelfSignedCertificate`` コマンドレットを使用した PowerShell

en: Active Directory Certificate Services
ja: Active Directory 証明書サービス

en: Active Directory Certificate Services is beyond of scope in this documentation but may be the best option to use when running in a domain environment. For more information, see the `Active Directory Certificate Services documentation <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc732625(v=ws.11)>`_.
ja: Active Directory Certificate Services は、このドキュメントでは対象外になりますが、ドメイン環境で実行する場合には、最適なオプションになるかもしれません。詳細は、`Active Directory Certificate Services のドキュメント <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc732625(v=ws.11)>`_ を参照してください。

en: Using the PowerShell cmdlet ``New-SelfSignedCertificate`` to generate a certificate for authentication only works when being generated from a Windows 10 or Windows Server 2012 R2 host or later. OpenSSL is still required to extract the private key from the PFX certificate to a PEM file for Ansible to use.
ja: PowerShell コマンドレット (``New-SelfSignedCertificate``) を使用して認証用の証明書を生成する場合、Windows 10 または Windows Server 2012 R2 ホスト以降から生成された場合にのみ機能します。PFX 証明書から Ansible が使用する PEM ファイルに秘密鍵を抽出するには、OpenSSL が依然として必要です。

en: To generate a certificate with ``OpenSSL``:
ja: ``OpenSSL`` で証明書を生成するには、以下を実行します。

en: To generate a certificate with ``New-SelfSignedCertificate``:
ja: ``New-SelfSignedCertificate`` で証明書を生成するには、以下を実行します。

en: To convert the PFX file to a private key that pywinrm can use, run the following command with OpenSSL ``openssl pkcs12 -in cert.pfx -nocerts -nodes -out cert_key.pem -passin pass: -passout pass:``
ja: PFX ファイルを pywinrm が使用できる秘密鍵に変換するには、OpenSSL で ``openssl pkcs12 -in cert.pfx -nocerts -nodes -out cert_key.pem -passin pass: -passout pass:`` コマンドを実行します。

en: Import a Certificate to the Certificate Store
ja: 証明書ストアへの証明書のインポート

en: Once a certificate has been generated, the issuing certificate needs to be imported into the ``Trusted Root Certificate Authorities`` of the ``LocalMachine`` store, and the client certificate public key must be present in the ``Trusted People`` folder of the ``LocalMachine`` store. For this example, both the issuing certificate and public key are the same.
ja: 証明書が生成されたら、発行した証明書を ``LocalMachine`` ストアの ``Trusted Root Certificate Authorities`` にインポートし、クライアント証明書の公開鍵を ``LocalMachine`` ストアの ``Trusted People`` ディレクトリーに存在させる必要があります。この例では、発行した証明書と公開鍵の両方が同じものです。

en: Following example shows how to import the issuing certificate:
ja: 以下の例では、発行した証明書をインポートする方法を示します。

en: If using ADCS to generate the certificate, then the issuing certificate will already be imported and this step can be skipped.
ja: ADCS を使用して証明書を生成する場合は、発行する証明書がすでにインポートされているため、この手順は省略できます。

en: The code to import the client certificate public key is:
ja: クライアント証明書の公開鍵をインポートするコードは以下のとおりです。

en: Mapping a Certificate to an Account
ja: 証明書のアカウントへのマッピング

en: Once the certificate has been imported, map it to the local user account::
ja: 証明書をインポートしたら、これをローカルユーザーアカウントにマッピングします。

en: Once this is complete, the hostvar ``ansible_winrm_cert_pem`` should be set to the path of the public key and the ``ansible_winrm_cert_key_pem`` variable should be set to the path of the private key.
ja: これが完了したら、ホスト変数 ``ansible_winrm_cert_pem`` に公開鍵のパスを、変数``ansible_winrm_cert_key_pem`` に秘密鍵のパスを設定してください。

en: NTLM is an older authentication mechanism used by Microsoft that can support both local and domain accounts. NTLM is enabled by default on the WinRM service, so no setup is required before using it.
ja: NTLM は、Microsoft が使用している古い認証メカニズムで、ローカルアカウントとドメインアカウントの両方をサポートしています。NTLM は、WinRM サービスでデフォルトで有効になっているため、使用する前に設定する必要はありません。

en: NTLM is the easiest authentication protocol to use and is more secure than ``Basic`` authentication. If running in a domain environment, ``Kerberos`` should be used instead of NTLM.
ja: NTLM は最も簡単に使用できる認証プロトコルであり、``Basic`` 認証よりも安全です。ドメイン環境で稼働している場合は、NTLM の代わりに ``Kerberos`` を使用する必要があります。

en: Kerberos has several advantages over using NTLM:
ja: Kerberos は NTLM の使用と比較して、以下のような利点があります。

en: NTLM is an older protocol and does not support newer encryption protocols.
ja: NTLM は古いプロトコルであり、新しい暗号化プロトコルをサポートしません。

en: NTLM is slower to authenticate because it requires more round trips to the host in the authentication stage.
ja: NTLM は、認証の段階でホストへのラウンドトリップが多くなるため、認証に時間がかかります。

en: Unlike Kerberos, NTLM does not allow credential delegation.
ja: Kerberos とは異なり、NTLM は認証情報の委譲を許可していません。

en: This example shows host variables configured to use NTLM authentication:
ja: 以下の例では、NTLM 認証を使用するように設定されているホスト変数を示しています。

en: Kerberos is the recommended authentication option to use when running in a domain environment. Kerberos supports features like credential delegation and message encryption over HTTP and is one of the more secure options that is available through WinRM.
ja: Kerberos は、ドメイン環境で実行する場合に使用する推奨の認証オプションです。Kerberos は、認証情報の委譲や HTTP でのメッセージ暗号化などの機能をサポートしており、WinRM で利用できるより安全なオプションの 1 つです。

en: Kerberos requires some additional setup work on the Ansible host before it can be used properly.
ja: Kerberos を正しく使用するには、Ansible ホスト上でいくつかの追加設定作業が必要です。

en: The following example shows host vars configured for Kerberos authentication:
ja: 以下の例は、Kerberos 認証に設定されたホスト変数を示しています。

en: As of Ansible version 2.3, the Kerberos ticket will be created based on ``ansible_user`` and ``ansible_password``. If running on an older version of Ansible or when ``ansible_winrm_kinit_mode`` is ``manual``, a Kerberos ticket must already be obtained. See below for more details.
ja: Ansible バージョン 2.3 以降では、``ansible_user`` と ``ansible_password`` に基づいて Kerberos チケットが作成されます。古いバージョンの Ansible で実行している場合や、``ansible_winrm_kinit_mode`` が ``manual`` の場合は、すでに Kerberos チケットを取得している必要があります。詳細は以下を参照してください。

en: There are some extra host variables that can be set::
ja: 設定可能な追加のホスト変数があります。

en: Installing the Kerberos Library
ja: Kerberos ライブラリーのインストール

en: Some system dependencies that must be installed prior to using Kerberos. The script below lists the dependencies based on the distro:
ja: Kerberos を使用する前にインストールする必要があるシステム依存関係があります。以下のスクリプトは、ディストリビューションに基づく依存関係を一覧表示します。

en: Once the dependencies have been installed, the ``python-kerberos`` wrapper can be install using ``pip``:
ja: 依存関係がインストールされたら、``pip`` を使用して ``python-kerberos`` ラッパーをインストールできます。

en: While Ansible has supported Kerberos auth through ``pywinrm`` for some time, optional features or more secure options may only be available in newer versions of the ``pywinrm`` and/or ``pykerberos`` libraries. It is recommended you upgrade each version to the latest available to resolve any warnings or errors. This can be done through tools like ``pip`` or a system package manager like ``dnf``, ``yum``, ``apt`` but the package names and versions available may differ between tools.
ja: Ansible はこれまで、``pywinrm`` を通じて Kerberos 認証をサポートしてきましたが、オプション機能やより安全なオプションは、``pywinrm`` ライブラリーまたは ``pykerberos`` ライブラリーの新しいバージョンでのみ利用できる場合があります。警告やエラーが発生した場合は、各バージョンを最新のものにアップグレードすることが推奨されます。この作業は、``pip`` のようなツールや、``dnf``、``yum``、``apt`` のようなシステムパッケージマネージャーで行うことができますが、パッケージ名や利用可能なバージョンはツールによって異なる場合があります。

en: Configuring Host Kerberos
ja: ホスト Kerberos の設定

en: Once the dependencies have been installed, Kerberos needs to be configured so that it can communicate with a domain. This configuration is done through the ``/etc/krb5.conf`` file, which is installed with the packages in the script above.
ja: 依存関係がインストールされたら、Kerberos がドメインと通信できるように設定する必要があります。この設定は、上のスクリプトでパッケージと一緒にインストールされた ``/etc/krb5.conf`` ファイルを通じて行われます。

en: To configure Kerberos, in the section that starts with:
ja: Kerberos を設定するには、以下で始まるセクションで行います。

en: Add the full domain name and the fully qualified domain names of the primary and secondary Active Directory domain controllers. It should look something like this:
ja: プライマリーおよびセカンダリーの Active Directory ドメインコントローラーの完全なドメイン名と完全修飾ドメイン名を追加します。以下のようになるはずです。

en: In the section that starts with:
ja: 以下で始まるセクションで、

en: Add a line like the following for each domain that Ansible needs access for:
ja: Ansible がアクセスする必要のある各ドメインに以下のような行を追加します。

en: You can configure other settings in this file such as the default domain. See `krb5.conf <https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html>`_ for more details.
ja: このファイルでは、デフォルトのドメインなど、その他の設定を行うことができます。詳細は `krb5.conf <https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html>`_ を参照してください。

en: Automatic Kerberos Ticket Management
ja: Kerberos チケットの自動管理

en: Ansible version 2.3 and later defaults to automatically managing Kerberos tickets when both ``ansible_user`` and ``ansible_password`` are specified for a host. In this process, a new ticket is created in a temporary credential cache for each host. This is done before each task executes to minimize the chance of ticket expiration. The temporary credential caches are deleted after each task completes and will not interfere with the default credential cache.
ja: Ansible バージョン 2.3 以降では、ホストに ``ansible_user`` と``ansible_password`` の両方が指定された場合は、デフォルトで Kerberos チケットを自動的に管理します。このプロセスでは、各ホストの一時的な認証情報キャッシュに新しいチケットが作成されます。これは、チケットが失効する可能性を最小限にするために、各タスクが実行される前に行われます。一時的な認証情報キャッシュは、各タスクが完了すると削除され、デフォルトの認証情報キャッシュに干渉することはありません。

en: To disable automatic ticket management, set ``ansible_winrm_kinit_mode=manual`` via the inventory.
ja: チケットの自動管理を無効にするには、インベントリーから ``ansible_winrm_kinit_mode=manual`` を設定してください。

en: Automatic ticket management requires a standard ``kinit`` binary on the control host system path. To specify a different location or binary name, set the ``ansible_winrm_kinit_cmd`` hostvar to the fully qualified path to a MIT krbv5 ``kinit``-compatible binary.
ja: 自動チケット管理には、制御ホストシステムのパスに標準の ``kinit`` バイナリーが必要です。別の場所やバイナリー名を指定するには、``ansible_winrm_kinit_cmd`` hostvar に MIT krbv5 ``kinit`` 互換バイナリーへの完全修飾パスを設定します。

en: Manual Kerberos Ticket Management
ja: Kerberos チケットの手動管理

en: To manually manage Kerberos tickets, the ``kinit`` binary is used. To obtain a new ticket the following command is used:
ja: Kerberos チケットを手動で管理するには、``kinit`` バイナリーを使用します。新しいチケットを取得するには、以下のコマンドを使用します。

en: The domain must match the configured Kerberos realm exactly, and must be in upper case.
ja: ドメインは設定された Kerberos レルムに完全に一致し、大文字である必要があります。

en: To see what tickets (if any) have been acquired, use the following command:
ja: 取得したチケット (存在する場合) を確認するには、以下のコマンドを使用します。

en: To destroy all the tickets that have been acquired, use the following command:
ja: 取得したすべてのチケットを破棄するには、以下のコマンドを使用します。

en: Troubleshooting Kerberos
ja: Kerberos のトラブルシューティング

en: Kerberos is reliant on a properly-configured environment to work. To troubleshoot Kerberos issues, ensure that:
ja: Kerberos は、適切に構成された環境でなければ動作しません。Kerberos の問題をトラブルシューティングするには、以下を確認してください。

en: The hostname set for the Windows host is the FQDN and not an IP address.
ja: Windows ホストのホスト名には、IP アドレスではなく FQDN であることを確認します。

en: The forward and reverse DNS lookups are working properly in the domain. To test this, ping the windows host by name and then use the ip address returned with ``nslookup``. The same name should be returned when using ``nslookup`` on the IP address.
ja: このドメインでは、DNS の正引きと逆引きが正常に動作しています。これをテストするには、Windows ホストに名前で ping を打ち、``nslookup`` で返された IP アドレスを使用します。IP アドレスに ``nslookup`` を使用すると、同じ名前が返されるはずです。

en: The Ansible host's clock is synchronized with the domain controller. Kerberos is time sensitive, and a little clock drift can cause the ticket generation process to fail.
ja: Ansible ホストの時計はドメインコントローラーと同期します。Kerberos は時間に敏感で、わずかな時計のずれにより、チケット生成プロセスが失敗する可能性があります。

en: Ensure that the fully qualified domain name for the domain is configured in the ``krb5.conf`` file. To check this, run::
ja: ドメインの完全修飾ドメイン名が、``krb5.conf`` ファイルに設定されていることを確認してください。これを確認するには、次のように実行します。

en: If the domain name returned by ``klist`` is different from the one requested, an alias is being used. The ``krb5.conf`` file needs to be updated so that the fully qualified domain name is used and not an alias.
ja: ``klist`` で返されたドメイン名が要求されたものと異なる場合は、エイリアスが使用されています。``krb5.conf`` ファイルを更新して、エイリアスではなく完全修飾ドメイン名を使用する必要があります。

en: If the default kerberos tooling has been replaced or modified (some IdM solutions may do this), this may cause issues when installing or upgrading the Python Kerberos library. As of the time of this writing, this library is called ``pykerberos`` and is known to work with both MIT and Heimdal Kerberos libraries. To resolve ``pykerberos`` installation issues, ensure the system dependencies for Kerberos have been met (see: `Installing the Kerberos Library`_), remove any custom Kerberos tooling paths from the PATH environment variable, and retry the installation of Python Kerberos library package.
ja: デフォルトの kerberos ツールが置き換えられたり変更されたりした場合 (いくつかの IdM ソリューションではそうなっているかもしれません)、Python Kerberos ライブラリーをインストールしたりアップグレードしたりする際に問題が発生する可能性があります。本ガイドの作成時点では、このライブラリーは ``pykerberos`` と呼ばれ、MIT と Heimdal Kerberos ライブラリーの両方で動作することが知られています。``pykerberos`` のインストール問題を解決するには、Kerberos のシステム依存性が満たされていることを確認し (参照: `Installing the Kerberos Library`_)、PATH 環境変数からカスタム Kerberos ツールパスを削除し、Python Kerberos ライブラリーパッケージのインストールを再試行してください。

en: CredSSP authentication is a newer authentication protocol that allows credential delegation. This is achieved by encrypting the username and password after authentication has succeeded and sending that to the server using the CredSSP protocol.
ja: CredSSP 認証は、認証情報の委譲を可能にする新しい認証プロトコルになります。これは、認証が成功した後のユーザー名とパスワードを暗号化し、それを CredSSP プロトコルを使用してサーバーに送信することで実現しています。

en: Because the username and password are sent to the server to be used for double hop authentication, ensure that the hosts that the Windows host communicates with are not compromised and are trusted.
ja: ユーザー名とパスワードをサーバーに送信してダブルホップ認証に使用するため、Windows ホストが通信するホストが漏洩しておらず、信頼できることを確認してください。

en: CredSSP can be used for both local and domain accounts and also supports message encryption over HTTP.
ja: CredSSP は、ローカルアカウントとドメインアカウントの両方に使用でき、HTTPでのメッセージ暗号化にも対応しています。

en: To use CredSSP authentication, the host vars are configured like so:
ja: CredSSP 認証を使用するには、以下のようにホスト変数を設定します。

en: There are some extra host variables that can be set as shown below::
ja: 以下のように設定できる追加のホスト変数があります。

en: CredSSP authentication is not enabled by default on a Windows host, but can be enabled by running the following in PowerShell:
ja: CredSSP 認証は、Windows ホストではデフォルトでは有効になっていませんが、PowerShell で以下を実行することで有効にすることができます。

en: Installing CredSSP Library
ja: CredSSP ライブラリーのインストール

en: The ``requests-credssp`` wrapper can be installed using ``pip``:
ja: ``requests-credssp`` ラッパーは、``pip`` を使用してインストールできます。

en: CredSSP and TLS 1.2
ja: CredSSP および TLS 1.2

en: By default the ``requests-credssp`` library is configured to authenticate over the TLS 1.2 protocol. TLS 1.2 is installed and enabled by default for Windows Server 2012 and Windows 8 and more recent releases.
ja: デフォルトでは、``requests-credssp`` ライブラリーは、TLS 1.2 プロトコルで認証するように設定されています。TLS 1.2 は、Windows Server 2012 および Windows 8 と、それ以降のリリースでは、デフォルトでインストールされ、有効になっています。

en: There are two ways that older hosts can be used with CredSSP:
ja: 古いホストを CredSSP で使用できる方法は 2 つあります。

en: Install and enable a hotfix to enable TLS 1.2 support (recommended for Server 2008 R2 and Windows 7).
ja: TLS 1.2 のサポートを有効にする Hotfix をインストールして有効にしてください (Server 2008 R2 および Windows 7 で推奨)。

en: Set ``ansible_winrm_credssp_disable_tlsv1_2=True`` in the inventory to run over TLS 1.0. This is the only option when connecting to Windows Server 2008, which has no way of supporting TLS 1.2
ja: インベントリーに ``ansible_winrm_credssp_disable_tlsv1_2=True`` を設定して、TLS 1.0 で実行するように設定します。これは、TLS 1.2 に対応していない Windows Server 2008 に接続する際の唯一の選択肢です。

en: See :ref:`winrm_tls12` for more information on how to enable TLS 1.2 on the Windows host.
ja: Windows ホストで TLS 1.2 を有効にする方法は、「:ref:`winrm_tls12`」を参照してください。

en: Set CredSSP Certificate
ja: CredSSP 証明書の設定

en: CredSSP works by encrypting the credentials through the TLS protocol and uses a self-signed certificate by default. The ``CertificateThumbprint`` option under the WinRM service configuration can be used to specify the thumbprint of another certificate.
ja: CredSSP は、TLS プロトコルで認証情報を暗号化して動作し、デフォルトでは自己署名証明書を使用します。WinRM サービス構成の``CertificateThumbprint`` オプションを使用して、別の証明書のサムプリントを指定することができます。

en: This certificate configuration is independent of the WinRM listener certificate. With CredSSP, message transport still occurs over the WinRM listener, but the TLS-encrypted messages inside the channel use the service-level certificate.
ja: この証明書構成は、WinRM リスナーの証明書とは独立しています。CredSSP では、メッセージトランスポートは依然として WinRM リスナーを介して行われますが、チャネル内の TLS 暗号化メッセージにはサービスレベル証明書が使用されます。

en: To explicitly set the certificate to use for CredSSP::
ja: CredSSP に使用する証明書を明示的に設定するには、以下を実行します。

en: Non-Administrator Accounts
ja: 管理者以外のアカウント

en: WinRM is configured by default to only allow connections from accounts in the local ``Administrators`` group. This can be changed by running:
ja: WinRM は、デフォルトで、ローカルの ``Administrators`` グループのアカウントからの接続のみを許可するように設定されています。これは、以下を実行して変更できます。

en: This will display an ACL editor, where new users or groups may be added. To run commands over WinRM, users and groups must have at least the ``Read`` and ``Execute`` permissions enabled.
ja: これにより、ACL エディターが表示され、新しいユーザーまたはグループを追加できます。WinRM でコマンドを実行するには、ユーザーおよびグループに少なくとも ``Read`` および ``Execute`` パーミッションが有効になっている必要があります。

en: While non-administrative accounts can be used with WinRM, most typical server administration tasks require some level of administrative access, so the utility is usually limited.
ja: WinRM では、管理者以外のアカウントを使用することもできますが、一般的なサーバー管理作業では、ある程度の管理者権限が必要となるため、実用性は限られてしまいます。

en: WinRM Encryption
ja: WinRM 暗号化

en: By default WinRM will fail to work when running over an unencrypted channel. The WinRM protocol considers the channel to be encrypted if using TLS over HTTP (HTTPS) or using message level encryption. Using WinRM with TLS is the recommended option as it works with all authentication options, but requires a certificate to be created and used on the WinRM listener.
ja: デフォルトでは、WinRM は、暗号化されていないチャンネル上で実行されると、動作に失敗します。WinRM プロトコルは、TLS over HTTP (HTTPS) を使用している場合や、メッセージレベルの暗号化を使用している場合は、チャンネルが暗号化されているとみなします。WinRM を TLS で使用することは、すべての認証オプションで動作するため、推奨されるオプションですが、WinRM リスナーで証明書を作成して使用する必要があります。

en: The ``ConfigureRemotingForAnsible.ps1`` creates a self-signed certificate and creates the listener with that certificate. If in a domain environment, ADCS can also create a certificate for the host that is issued by the domain itself.
ja: ``ConfigureRemotingForAnsible.ps1`` は、自己署名証明書を作成し、その証明書でリスナーを作成します。ドメイン環境であれば、ADCS はドメイン自体が発行するホスト用の証明書を作成することもできる。

en: If using HTTPS is not an option, then HTTP can be used when the authentication option is ``NTLM``, ``Kerberos`` or ``CredSSP``. These protocols will encrypt the WinRM payload with their own encryption method before sending it to the server. The message-level encryption is not used when running over HTTPS because the encryption uses the more secure TLS protocol instead. If both transport and message encryption is required, set ``ansible_winrm_message_encryption=always`` in the host vars.
ja: HTTPS を使用することができない場合は、認証オプションが ``NTLM``、``Kerberos``、または ``CredSSP`` であれば、HTTP を使用することができます。これらのプロトコルは、WinRM のペイロードを独自の暗号化方式で暗号化してからサーバーに送信します。メッセージレベルの暗号化は、HTTPS で実行する場合には使用されません。トランスポートとメッセージの両方の暗号化が必要な場合は、ホスト変数に ``ansible_winrm_message_encryption=always`` を設定してください。

en: Message encryption over HTTP requires pywinrm>=0.3.0.
ja: HTTPでのメッセージ暗号化には 0.3.0 以上の pywinrm が必要です。

en: A last resort is to disable the encryption requirement on the Windows host. This should only be used for development and debugging purposes, as anything sent from Ansible can be viewed, manipulated and also the remote session can completely be taken over by anyone on the same network. To disable the encryption requirement::
ja: 最後の手段として、Windows ホストの暗号化要件を無効にすることができます。これは、Ansible から送信されたものはすべて閲覧、操作でき、また同じネットワーク上の誰もがリモートセッションを完全に乗っ取ることができるため、開発やデバッグの目的でのみ使用してください。暗号化を無効にするには、以下の手順に従います。

en: Do not disable the encryption check unless it is absolutely required. Doing so could allow sensitive information like credentials and files to be intercepted by others on the network.
ja: どうしても必要な場合を除き、暗号化チェックを無効にしないでください。暗号化チェックを無効にすると、認証情報やファイルなどの機密情報がネットワーク上の他の人に傍受される可能性があります。

en: Inventory Options
ja: インベントリーオプション

en: Ansible's Windows support relies on a few standard variables to indicate the username, password, and connection type of the remote hosts. These variables are most easily set up in the inventory, but can be set on the ``host_vars``/ ``group_vars`` level.
ja: Ansible の Windows サポートは、リモートホストのユーザー名、パスワード、接続タイプを示すいくつかの標準変数に依存しています。これらの変数はインベントリーで最も簡単に設定できますが、``host_vars``/``group_vars`` レベルで設定することもできます。

en: When setting up the inventory, the following variables are required:
ja: インベントリーを設定する際に、以下の変数が必要になります。

en: Using the variables above, Ansible will connect to the Windows host with Basic authentication through HTTPS. If ``ansible_user`` has a UPN value like ``username@MY.DOMAIN.COM`` then the authentication option will automatically attempt to use Kerberos unless ``ansible_winrm_transport`` has been set to something other than ``kerberos``.
ja: 上記の変数を使用すると、Ansible は HTTPS を通じて Basic 認証で Windows ホストに接続します。``ansible_user`` に ``username@MY.DOMAIN.COM`` のような UPN 値がある場合は、``ansible_winrm_transport`` が ``kerberos`` 以外に設定されていない限り、認証オプションは自動的に Kerberos の使用を試みます。

en: The following custom inventory variables are also supported for additional configuration of WinRM connections:
ja: 以下のカスタムインベントリー変数も、WinRM 接続の追加設定のためにサポートされています。

en: ``ansible_port``: The port WinRM will run over, HTTPS is ``5986`` which is the default while HTTP is ``5985``
ja: ``ansible_port``: WinRM が実行するポートです。HTTPS のデフォルトは ``5986`` で、HTTP のデフォルトは ``5985`` です。

en: ``ansible_winrm_scheme``: Specify the connection scheme (``http`` or ``https``) to use for the WinRM connection. Ansible uses ``https`` by default unless ``ansible_port`` is ``5985``
ja: ``ansible_winrm_scheme``: WinRM 接続に使用する接続スキーム (``http`` または ``https``) を指定します。Ansible は、``ansible_port`` が ``5985`` に指定されていない限り、デフォルトで ``https`` を使用します。

en: ``ansible_winrm_path``: Specify an alternate path to the WinRM endpoint, Ansible uses ``/wsman`` by default
ja: ``ansible_winrm_path``: WinRMエンドポイントへの別のパスを指定します。Ansibleはデフォルトで ``/wsman`` を使用します。

en: ``ansible_winrm_realm``: Specify the realm to use for Kerberos authentication. If ``ansible_user`` contains ``@``, Ansible will use the part of the username after ``@`` by default
ja: ``ansible_winrm_realm``: Kerberos 認証に使用するレルムを指定します。``ansible_user`` に ``@`` が含まれる場合、Ansible はデフォルトで ``@`` の後にユーザー名の一部を使用します。

en: ``ansible_winrm_transport``: Specify one or more authentication transport options as a comma-separated list. By default, Ansible will use ``kerberos, basic`` if the ``kerberos`` module is installed and a realm is defined, otherwise it will be ``plaintext``
ja: ``ansible_winrm_transport``: 1 つ以上の認証トランスポートオプションをコンマ区切りのリストで指定します。デフォルトでは、``kerberos`` モジュールがインストールされていてレルムが定義されている場合、Ansible は ``kerberos, basic`` を使用し、それ以外の場合は ``plaintext`` になります。

en: ``ansible_winrm_server_cert_validation``: Specify the server certificate validation mode (``ignore`` or ``validate``). Ansible defaults to ``validate`` on Python 2.7.9 and higher, which will result in certificate validation errors against the Windows self-signed certificates. Unless verifiable certificates have been configured on the WinRM listeners, this should be set to ``ignore``
ja: ``ansible_winrm_server_cert_validation``: サーバー証明書の検証モード (``ignore`` または``validate``) を指定します。Ansible のデフォルトは、Python 2.7.9 以降では ``validate`` で、これは Windows の自己署名証明書に対して証明書の検証エラーが発生します。WinRM リスナーで検証可能な証明書が設定されていない場合は、この設定を ``ignore`` に設定する必要があります。

en: ``ansible_winrm_operation_timeout_sec``: Increase the default timeout for WinRM operations, Ansible uses ``20`` by default
ja: ``ansible_winrm_operation_timeout_sec``: WinRM 操作のデフォルトタイムアウトを増やすと、Ansible はデフォルトで ``20`` を使用します。

en: ``ansible_winrm_read_timeout_sec``: Increase the WinRM read timeout, Ansible uses ``30`` by default. Useful if there are intermittent network issues and read timeout errors keep occurring
ja: ``ansible_winrm_read_timeout_sec``: WinRM の読み取りタイムアウトを増やします。Ansible はデフォルトで ``30`` を使用します。ネットワークの問題が断続的に発生し、読み取りタイムアウトのエラーが発生し続ける場合に有効です。

en: ``ansible_winrm_message_encryption``: Specify the message encryption operation (``auto``, ``always``, ``never``) to use, Ansible uses ``auto`` by default. ``auto`` means message encryption is only used when ``ansible_winrm_scheme`` is ``http`` and ``ansible_winrm_transport`` supports message encryption. ``always`` means message encryption will always be used and ``never`` means message encryption will never be used
ja: ``ansible_winrm_message_encryption``: 使用するメッセージ暗号化操作 (``auto``、``always``、``never``) を指定します。Ansible はデフォルトで``auto`` を使用します。``auto`` は、``ansible_winrm_scheme`` が``http`` および ``ansible_winrm_transport`` がメッセージ暗号化をサポートしている場合に限り、メッセージ暗号化が使用されることを意味します。``always`` は、メッセージ暗号化が常に使用されることを意味し、``never`` は、メッセージ暗号化が決して使用されないことを意味します。

en: ``ansible_winrm_ca_trust_path``: Used to specify a different cacert container than the one used in the ``certifi`` module. See the HTTPS Certificate Validation section for more details.
ja: ``ansible_winrm_ca_trust_path``: ``certifi`` モジュールで使用されているものとは異なる cacert コンテナーを指定するために使用します。詳細は、「HTTPS 証明書の検証」セクションを参照してください。

en: ``ansible_winrm_send_cbt``: When using ``ntlm`` or ``kerberos`` over HTTPS, the authentication library will try to send channel binding tokens to mitigate against man in the middle attacks. This flag controls whether these bindings will be sent or not (default: ``yes``).
ja: ``ansible_winrm_send_cbt``: ``ntlm`` または ``kerberos`` を HTTPS で使用する場合、認証ライブラリーは、中間者攻撃を緩和するためにチャネルバインディングトークンの送信を試みます。このフラグは、これらのバインディングを送信するかどうかを制御します (デフォルト: ``yes``)。

en: ``ansible_winrm_*``: Any additional keyword arguments supported by ``winrm.Protocol`` may be provided in place of ``*``
ja: ``ansible_winrm_*``:``winrm.Protocol`` でサポートされている任意の追加キーワード引数は、代わりに ``*`` で指定できます。

en: In addition, there are also specific variables that need to be set for each authentication option. See the section on authentication above for more information.
ja: さらに、各認証オプションで設定する必要がある特定の変数もあります。詳細は、上記の認証に関するセクションを参照してください。

en: Ansible 2.0 has deprecated the "ssh" from ``ansible_ssh_user``, ``ansible_ssh_pass``, ``ansible_ssh_host``, and ``ansible_ssh_port`` to become ``ansible_user``, ``ansible_password``, ``ansible_host``, and ``ansible_port``. If using a version of Ansible prior to 2.0, the older style (``ansible_ssh_*``) should be used instead. The shorter variables are ignored, without warning, in older versions of Ansible.
ja: Ansible 2.0 では、``ansible_ssh_user``、``ansible_ssh_pass``、``ansible_ssh_host``、および ``ansible_ssh_port`` の「ssh」が非推奨となり、``ansible_user``、``ansible_password``、``ansible_host``、および ``ansible_port`` となりました。Ansible 2.0 より前のバージョンを使用している場合は、代わりに古いスタイル (``ansible_ssh_*``) を使用する必要があります。短い方の変数は、古いバージョンの Ansible では警告なしに無視されます。

en: ``ansible_winrm_message_encryption`` is different from transport encryption done over TLS. The WinRM payload is still encrypted with TLS when run over HTTPS, even if ``ansible_winrm_message_encryption=never``.
ja: ``ansible_winrm_message_encryption`` は、TLS 上で行われるトランスポート暗号化とは異なります。WinRM ペイロードは、``ansible_winrm_message_encryption=never`` であっても、HTTPS で実行された場合でも TLS で暗号化されます。

en: IPv6 Addresses
ja: IPv6 アドレス

en: IPv6 addresses can be used instead of IPv4 addresses or hostnames. This option is normally set in an inventory. Ansible will attempt to parse the address using the `ipaddress <https://docs.python.org/3/library/ipaddress.html>`_ package and pass to pywinrm correctly.
ja: IPv4 アドレスやホスト名の代わりに、IPv6 アドレスを使用することができます。このオプションは通常、インベントリーで設定します。Ansible は、`ipaddress <https://docs.python.org/3/library/ipaddress.html>`_ パッケージを使用してアドレスの解析を試み、pywinrm に正しく渡します。

en: When defining a host using an IPv6 address, just add the IPv6 address as you would an IPv4 address or hostname:
ja: IPv6 アドレスを使用してホストを定義する場合は、IPv4 アドレスやホスト名と同じように IPv6 アドレスを追加するだけです。

en: The ipaddress library is only included by default in Python 3.x. To use IPv6 addresses in Python 2.7, make sure to run ``pip install ipaddress`` which installs a backported package.
ja: ipaddress ライブラリーは Python 3.x にのみデフォルトで含まれています。Python 2.7 で IPv6 アドレスを使用するには、バックポートされたパッケージをインストールする ``pip install ipaddress`` を必ず実行してください。

en: HTTPS Certificate Validation
ja: HTTPS 証明書の検証

en: As part of the TLS protocol, the certificate is validated to ensure the host matches the subject and the client trusts the issuer of the server certificate. When using a self-signed certificate or setting ``ansible_winrm_server_cert_validation: ignore`` these security mechanisms are bypassed. While self signed certificates will always need the ``ignore`` flag, certificates that have been issued from a certificate authority can still be validated.
ja: TLS プロトコルの一環として、証明書が検証され、ホストがサブジェクトと一致し、クライアントがサーバー証明書の発行者を信頼していることが確認されます。自己署名証明書を使用したり、``ansible_winrm_server_cert_validation: ignore`` を設定したりすると、これらのセキュリティーメカニズムが回避されます。自己署名証明書には常に ``ignore`` フラグが必要ですが、認証局から発行された証明書は検証されます。

en: One of the more common ways of setting up a HTTPS listener in a domain environment is to use Active Directory Certificate Service (AD CS). AD CS is used to generate signed certificates from a Certificate Signing Request (CSR). If the WinRM HTTPS listener is using a certificate that has been signed by another authority, like AD CS, then Ansible can be set up to trust that issuer as part of the TLS handshake.
ja: ドメイン環境で HTTPS リスナーをセットアップする一般的な方法の 1 つは、Active Directory Certificate Service (AD CS) を使用することである。AD CS は、CSR (Certificate Signing Request) から署名付き証明書を生成するために使用されます。WinRM HTTPS リスナーが AD CS のような別の機関によって署名された証明書を使用している場合、Ansible は TLS ハンドシェイクの一部としてその発行者を信頼するように設定することができます。

en: To get Ansible to trust a Certificate Authority (CA) like AD CS, the issuer certificate of the CA can be exported as a PEM encoded certificate. This certificate can then be copied locally to the Ansible controller and used as a source of certificate validation, otherwise known as a CA chain.
ja: AD CS のような認証局 (CA) を Ansible に信頼させるには、CA の発行者証明書を PEM エンコード証明書としてエクスポートします。この証明書は、Ansible コントローラーのローカルにコピーして、証明書検証のソースとして使用することができます (CA チェーンとも呼ばれます)。

en: The CA chain can contain a single or multiple issuer certificates and each entry is contained on a new line. To then use the custom CA chain as part of the validation process, set ``ansible_winrm_ca_trust_path`` to the path of the file. If this variable is not set, the default CA chain is used instead which is located in the install path of the Python package `certifi <https://github.com/certifi/python-certifi>`_.
ja: CA チェーンには、単一または複数の発行者証明書を含めることができ、各エントリーは改行されます。認証プロセスの一部としてカスタム CA チェーンを使用するには、``ansible_winrm_ca_trust_path`` にファイルのパスを設定します。この変数が設定されていない場合は、Python パッケージ `certifi <https://github.com/certifi/python-certifi>`_ のインストールパスにあるデフォルトの CAチ ェーンが使用されます。

en: Each HTTP call is done by the Python requests library which does not use the systems built-in certificate store as a trust authority. Certificate validation will fail if the server's certificate issuer is only added to the system's truststore.
ja: 各 HTTP コールは Python リクエストライブラリーによって行われ、システムに組み込まれた証明書ストアを信頼機関として使用しません。サーバーの証明書発行者がシステムのトラストストアに追加されていない場合、証明書の検証は失敗します。

en: TLS 1.2 Support
ja: TLS 1.2 のサポート

en: As WinRM runs over the HTTP protocol, using HTTPS means that the TLS protocol is used to encrypt the WinRM messages. TLS will automatically attempt to negotiate the best protocol and cipher suite that is available to both the client and the server. If a match cannot be found then Ansible will error out with a message similar to::
ja: WinRM は HTTP プロトコル上で動作するため、HTTPS を使用するということは、WinRM メッセージの暗号化に TLS プロトコルが使用されることを意味します。TLS は、クライアントとサーバーの両方で利用可能な、最適なプロトコルと暗号スイートを自動的に取り決めようとします。一致するものが見つからない場合、Ansible は次のようなメッセージでエラーになります。

en: Commonly this is when the Windows host has not been configured to support TLS v1.2 but it could also mean the Ansible controller has an older OpenSSL version installed.
ja: これは、Windows ホストが TLS v1.2 をサポートするように設定されていない場合ですが、Ansible コントローラーに古い OpenSSL バージョンがインストールされていることも意味します。

en: Windows 8 and Windows Server 2012 come with TLS v1.2 installed and enabled by default but older hosts, like Server 2008 R2 and Windows 7, have to be enabled manually.
ja: Windows 8 および Windows Server 2012 には、デフォルトで TLS v1.2 がインストールされ、有効になっていますが、Server 2008 R2 や Windows 7 などの古いホストは手動で有効にする必要があります。

en: There is a bug with the TLS 1.2 patch for Server 2008 which will stop Ansible from connecting to the Windows host. This means that Server 2008 cannot be configured to use TLS 1.2. Server 2008 R2 and Windows 7 are not affected by this issue and can use TLS 1.2.
ja: Server 2008 の TLS 1.2 パッチにはバグがあり、Ansible の Windows ホストへの接続が停止してしまいます。これは、Server 2008 が TLS 1.2 を使用するように設定できないことを意味します。Server 2008 R2 とWindows 7 はこの問題の影響を受けず、TLS 1.2 を使用できます。

en: To verify what protocol the Windows host supports, you can run the following command on the Ansible controller::
ja: Windows ホストが対応しているプロトコルを確認するには、Ansible コントローラーで以下のコマンドを実行します。

en: The output will contain information about the TLS session and the ``Protocol`` line will display the version that was negotiated::
ja: 出力には TLS セッションに関する情報が含まれ、``Protocol`` 行にはネゴシエートされたバージョンが表示されます。

en: If the host is returning ``TLSv1`` then it should be configured so that TLS v1.2 is enable. You can do this by running the following PowerShell script:
ja: ホストが ``TLSv1`` を返す場合は、TLS v1.2 が有効になるように設定する必要があります。これは、次の PowerShell スクリプトを実行することで行うことができます。

en: The below Ansible tasks can also be used to enable TLS v1.2:
ja: 以下の Ansible タスクを使用して TLS v1.2 を有効にすることもできます。

en: There are other ways to configure the TLS protocols as well as the cipher suites that are offered by the Windows host. One tool that can give you a GUI to manage these settings is `IIS Crypto <https://www.nartac.com/Products/IISCrypto/>`_ from Nartac Software.
ja: TLS プロトコルや、Windows ホストが提供する暗号スイートを設定する方法は他にもあります。これらの設定を管理するための GUI を提供するツールとして、Nartac Software 社の `IIS Crypto <https://www.nartac.com/Products/IISCrypto/>`_ があります。

en: Due to the design of the WinRM protocol , there are a few limitations when using WinRM that can cause issues when creating playbooks for Ansible. These include:
ja: WinRM プロトコルの設計上、WinRM を使用する際にはいくつかの制限があり、Ansible の Playbook を作成する際に問題となることがあります。これには次のようなものがあります。

en: Credentials are not delegated for most authentication types, which causes authentication errors when accessing network resources or installing certain programs.
ja: ほとんどの認証タイプで認証情報が委譲されていないため、ネットワークリソースへのアクセスや特定のプログラムのインストール時に認証エラーが発生することがありました。

en: Many calls to the Windows Update API are blocked when running over WinRM.
ja: WinRM 経由で実行すると、Windows Update API への多くの呼び出しがブロックされます。

en: Some programs fail to install with WinRM due to no credential delegation or because they access forbidden Windows API like WUA over WinRM.
ja: 認証情報の委譲や、WUA over WinRM などの禁止されている Windows API へのアクセスにより、一部のプログラムは WinRM でインストールできない場合があります。

en: Commands under WinRM are done under a non-interactive session, which can prevent certain commands or executables from running.
ja: WinRM のコマンドは非対話型セッションで実行されるため、特定のコマンドや実行ファイルが実行できない場合があります。

en: You cannot run a process that interacts with ``DPAPI``, which is used by some installers (like Microsoft SQL Server).
ja: 一部のインストーラー (Microsoft SQL Server など) が使用する ``DPAPI`` と対話するプロセスを実行することはできません。

en: Some of these limitations can be mitigated by doing one of the following:
ja: この制限の一部は、以下のいずれかを実行して軽減できます。

en: Set ``ansible_winrm_transport`` to ``credssp`` or ``kerberos`` (with ``ansible_winrm_kerberos_delegation=true``) to bypass the double hop issue and access network resources
ja: ダブルホップ問題を回避してネットワークリソースにアクセスするために、``ansible_winrm_transport`` を``credssp`` または``kerberos`` (``ansible_winrm_kerberos_delegation=true`` を使用) に設定します。

en: Use ``become`` to bypass all WinRM restrictions and run a command as it would locally. Unlike using an authentication transport like ``credssp``, this will also remove the non-interactive restriction and API restrictions like WUA and DPAPI
ja: ``become`` を使用すると、すべての WinRM 制限を回避して、ローカルと同様にコマンドを実行できます。``credssp`` のような認証トランスポートを使用する場合とは異なり、非対話型の制限や、WUA や DPAPI などの API の制限も解除されます。

en: Use a scheduled task to run a command which can be created with the ``win_scheduled_task`` module. Like ``become``, this bypasses all WinRM restrictions but can only run a command and not modules.
ja: ``win_scheduled_task`` モジュールで作成されるコマンドを実行するために、スケジュールされたタスクを使用します。``become`` と同様に、WinRM の制限をすべて回避しますが、実行できるのはコマンドのみで、モジュールは実行できません。
