diff --git a/exercises/ansible_rhel/1.6-templates/README.es.md b/exercises/ansible_rhel/1.6-templates/README.es.md
index fde52080e..fe3dcd35c 100644
--- a/exercises/ansible_rhel/1.6-templates/README.es.md
+++ b/exercises/ansible_rhel/1.6-templates/README.es.md
@@ -1,121 +1,114 @@
-# Workshop - Plantillas
+# Ejercicio de Taller - Plantillas
-**Read this in other languages**:
-
 [English](README.md), [日本語](README.ja.md),  [Portugues do Brasil](README.pt-br.md),  [Française](README.fr.md), [Español](README.es.md).
+**Leer esto en otros idiomas**:
+
 [Inglés](README.md),  [Japonés](README.ja.md),  [Portugués de Brasil](README.pt-br.md),  [Francés](README.fr.md),  [Español](README.es.md).
-## Tabla de contenidos
+## Tabla de Contenidos
-* [Objetivos](#Objetivos)
-* [Guía](#Guía)
-* [Paso 1 - Uso de plantillas en Playbooks](#Paso-1---Uso-de-plantillas-en-Playbooks)
-* [Paso 2 - Laboratorios de desafío](#Paso-2---Laboratorios-de-desafío)
+- [Objetivo](#objetivo)
+- [Guía](#guía)
+ - [Paso 1 - Introducción a las Plantillas Jinja2](#paso-1---introducción-a-las-plantillas-jinja2)
+ - [Paso 2 - Creando Tu Primera Plantilla](#paso-2---creando-tu-primera-plantilla)
+ - [Paso 3 - Desplegando la Plantilla con un Playbook](#paso-3---desplegando-la-plantilla-con-un-playbook)
+ - [Paso 4 - Ejecutando el Playbook](#paso-4---ejecutando-el-playbook)
-# Objetivos
+## Objetivo
-Este ejercicio cubrirá las plantillas de Jinja2. Ansible utiliza plantillas de Jinja2 para modificar archivos antes de que se distribuyan a hosts administrados. Jinja2 es uno de los motores de plantillas más utilizados para Python ().
+El Ejercicio 1.5 introduce las plantillas Jinja2 dentro de Ansible, una característica poderosa para generar archivos dinámicos a partir de plantillas. Aprenderás cómo elaborar plantillas que incorporan datos específicos del host, permitiendo la creación de archivos de configuración personalizados para cada host gestionado.
-# Guía
+## Guía
-## Paso 1 - Uso de plantillas en Playbooks
+### Paso 1 - Introducción a las Plantillas Jinja2
-Cuando se ha creado una plantilla para un archivo, se puede implementar en los hosts administrados mediante el módulo `template`, que admite la transferencia de un archivo local desde el nodo de control a los hosts administrados.
+Ansible utiliza Jinja2, un lenguaje de plantillas ampliamente utilizado para Python, permitiendo la generación de contenido dinámico dentro de los archivos. Esta capacidad es particularmente útil para configurar archivos que deben diferir de un host a otro.
-Como ejemplo de uso de plantillas, cambiará el archivo motd para que contenga datos específicos del host.
+### Paso 2 - Creando Tu Primera Plantilla
-En primer lugar, cree el directorio `templates` que contendrá los recursos de plantilla en `~/ansible-files/`:
+Las plantillas terminan con una extensión `.j2` y mezclan contenido estático con marcadores de posición dinámicos encerrados en `{{ }}`.
+En el siguiente ejemplo, vamos a crear una plantilla para el Mensaje del Día (MOTD) que incluye información dinámica del host.
+
+#### Configurar el Directorio de Plantillas:
+
+Asegúrate de que exista un directorio de plantillas dentro de tu directorio lab_inventory para organizar tus plantillas.
```bash
-[student@ansible ansible-files]$ mkdir templates
+mkdir -p ~/lab_inventory/templates
```
-A continuación, en el directorio `~/ansible-files/templates/`, cree el archivo de plantilla `motd-facts.j2`:
-
-```html+jinja
-Welcome to {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-deployed on {{ ansible_architecture }} architecture.
+#### Desarrollar la Plantilla MOTD:
+
+Crea un archivo llamado `motd.j2` en el directorio de plantillas con el siguiente contenido:
+
+```jinja
+Bienvenido a {{ ansible_hostname }}.
+SO: {{ ansible_distribution }} {{ ansible_distribution_version }}
+Arquitectura: {{ ansible_architecture }}
```
-
-El archivo de plantilla contiene el texto básico que se copiará más adelante. También contiene variables que se reemplazarán en las máquinas de destino individualmente.
+Esta plantilla muestra dinámicamente el nombre del host, la distribución del SO, la versión y la arquitectura de cada host gestionado.
-A continuación, necesitamos un playbook para usar esta plantilla. En el directorio `~/ansible-files/`, cree el Playbook `motd-facts.yml`:
+### Paso 3 - Desplegando la Plantilla con un Playbook
+
+Utiliza el módulo `ansible.builtin.template` en un playbook para distribuir y renderizar la plantilla a través de tus hosts gestionados.
+
+Modifica el Playbook `system_setup.yml` con el siguiente contenido:
```yaml
---
-- name: Fill motd file with host data
- hosts: node1
+- name: Configuración Básica del Sistema
+ hosts: all
become: true
tasks:
- - template:
- src: motd-facts.j2
+ - name: Actualizar MOTD desde Plantilla Jinja2
+ ansible.builtin.template:
+ src: templates/motd.j2
dest: /etc/motd
- owner: root
- group: root
- mode: 0644
+ handlers:
+ - name: Recargar Firewall
+ ansible.builtin.service:
+ name: firewalld
+ state: reloaded
```
-Usted ha hecho esto un par de veces por ahora:
-
- - Entender lo que hace el Playbook.
-
- - Ejecutar el Playbook `motd-facts.yml`.
-
- - Inicie sesión en node1 a través de SSH y compruebe el mensaje del contenido del día.
- - Cierre la sesión del nodo1.
-
-Debería ver cómo Ansible reemplaza las variables con los facts que descubrió del sistema.
-
-## Paso 2 - Laboratorios de desafío
-
-Agregue una línea a la plantilla para listar el kernel actual del nodo administrado.
-
- - Encuentra un fact que contenga la versión del kernel usando los comandos que aprendiste en el capítulo "Ansible Facts".
+El módulo `ansible.builtin.template` toma la plantilla `motd.j2` y genera un archivo `/etc/motd` en cada host, llenando los marcadores de posición de la plantilla con los hechos reales del host.
+### Paso 4 - Ejecutando el Playbook
-> **Consejo**
->
-> Hacer un `grep -i` para el kernel
+Ejecuta el playbook para aplicar tu MOTD personalizado en todos los hosts gestionados:
- - Modificar la plantilla para utilizar el fact que encontró.
-
- - Ejecute el Playbook de nuevo.
-
-
-> **Advertencia**
->
-> **Solución a continuación\!**
-
-
- - Encuentra el fact:
```bash
-[student@ansible ansible-files]$ ansible node1 -m setup|grep -i kernel
- "ansible_kernel": "3.10.0-693.el7.x86_64",
-```
-
- - Modificar la plantilla `motd-facts.j2`:
-
-```html+jinja
-Welcome to {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-deployed on {{ ansible_architecture }} architecture
-running kernel {{ ansible_kernel }}.
+[student@ansible-1 lab_inventory]$ ansible-navigator run system_setup.yml -m stdout
+
+PLAY [Configuración Básica del Sistema] ****************************************
+.
+.
+.
+
+TASK [Actualizar MOTD desde Plantilla Jinja2] **********************************
+changed: [node1]
+changed: [node2]
+changed: [node3]
+changed: [ansible-1]
+
+RECAP **************************************************************************
+ansible-1 : ok=6 changed=1 unreachable=0 failed=0 skipped=2 rescued=0 ignored=0
+node1 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node2 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node3 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
```
-
- - Ejecute el playbook.
-```
-[student1@ansible ~]$ ansible-playbook motd-facts.yml
-```
+Verifica los cambios conectándote por SSH al nodo, y deberías ver el mensaje del día:
- - Verifique el nuevo mensaje a través del login por SSH al `node1`.
-```
-[student1@ansible ~]$ ssh node1
-Welcome to node1.
-RedHat 8.1
-deployed on x86_64 architecture
-running kernel 4.18.0-147.8.1.el8_1.x86_64.
+```bash
+[rhel@control ~]$ ssh node1
+
+Bienvenido a node1.
+SO: RedHat 8.7
+Arquitectura: x86_64
+Registra este sistema en Red Hat Insights: insights-client --register
+Crea una cuenta o ve todos tus sistemas en https://red.ht/insights-dashboard
+Último acceso: Lun Ene 29 16:30:31 2024 desde 10.5.1.29
```
----
@@ -124,3 +117,4 @@ running kernel 4.18.0-147.8.1.el8_1.x86_64.
[Ejercicio anterior](../1.5-handlers/README.es.md) - [Próximo Ejercicio](../1.7-role/README.es.md)
[Haga clic aquí para volver al Taller Ansible for Red Hat Enterprise Linux](../README.md#section-1---ansible-engine-exercises)
+
diff --git a/exercises/ansible_rhel/1.6-templates/README.fr.md b/exercises/ansible_rhel/1.6-templates/README.fr.md
index c77c2da20..848d4f597 100644
--- a/exercises/ansible_rhel/1.6-templates/README.fr.md
+++ b/exercises/ansible_rhel/1.6-templates/README.fr.md
@@ -1,125 +1,125 @@
-# Atelier - Les templates
+# Exercice de l'Atelier - Modèles
-**Lisez ceci dans d'autres langues**:
-
 [English](README.md), [日本語](README.ja.md),  [Portugues do Brasil](README.pt-br.md),  [Française](README.fr.md), [Español](README.es.md).
+**Lisez ceci dans d'autres langues** :
+
 [Anglais](README.md),  [Japonais](README.ja.md),  [Portugais du Brésil](README.pt-br.md),  [Français](README.fr.md),  [Espagnol](README.es.md).
-## Table des matières
+## Table des Matières
-* [Objectif](#objectif)
-* [Guide](#guide)
-* [Étape 1 - Utilisation des templates](#Étape-1---utilisation-des-templates)
-* [Étape 2 - Défi: Les templates](#Étape-2---défi-les-templates)
+- [Objectif](#objectif)
+- [Guide](#guide)
+ - [Étape 1 - Introduction à la Templatisation Jinja2](#étape-1---introduction-à-la-templatisation-jinja2)
+ - [Étape 2 - Création de Votre Premier Modèle](#étape-2---création-de-votre-premier-modèle)
+ - [Étape 3 - Déploiement du Modèle avec un Playbook](#étape-3---déploiement-du-modèle-avec-un-playbook)
+ - [Étape 4 - Exécution du Playbook](#étape-4---exécution-du-playbook)
-# Objectif
+## Objectif
-Cet exercice couvre les templates. Ansible utilise les templates Jinja2 pour modifier les fichiers avant qu'ils ne soient distribués aux hôtes gérés. Jinja2 est l'un des moteurs de modèles les plus utilisés pour Python ().
+L'Exercice 1.5 introduit la templatisation Jinja2 au sein d'Ansible, une fonctionnalité puissante pour générer des fichiers dynamiques à partir de modèles. Vous apprendrez à créer des modèles qui intègrent des données spécifiques à l'hôte, permettant la création de fichiers de configuration sur mesure pour chaque hôte géré.
-# Guide
+## Guide
-## Étape 1 - Utilisation des templates
+### Étape 1 - Introduction à la Templatisation Jinja2
-Lorsqu'un template de fichier a été créé, il peut être déployé sur les hôtes gérés à l'aide du module `template`, qui prend en charge le transfert d'un fichier local du nœud de contrôle vers les hôtes gérés.
+Ansible utilise Jinja2, un langage de templatisation largement utilisé pour Python, permettant la génération de contenu dynamique dans les fichiers. Cette capacité est particulièrement utile pour configurer des fichiers qui doivent différer d'un hôte à l'autre.
-Comme exemple d'utilisation d'un template, vous allez modifier le fichier motd pour qu'il contienne des données spécifiques à l'hôte.
+### Étape 2 - Création de Votre Premier Modèle
-Créez d'abord le répertoire `templates` pour contenir les ressources de template dans `~/ansible-files/`:
-```bash
-[student@ansible ansible-files]$ mkdir templates
-```
+Les modèles se terminent par une extension `.j2` et mélangent du contenu statique avec des espaces réservés dynamiques entourés de `{{ }}`.
-Ensuite, dans le répertoire `~/ansible-files/templates/` créez le template `motd-facts.j2`:
+Dans l'exemple suivant, créons un modèle pour le Message du Jour (MOTD) qui inclut des informations dynamiques sur l'hôte.
-
-```html+jinja
-Welcome to {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-deployed on {{ ansible_architecture }} architecture.
-```
-
+#### Configuration du Répertoire des Modèles :
-Le template contient le texte de base qui sera ensuite recopié. Il contient également des variables qui seront remplacées individuellement sur les machines cibles.
+Assurez-vous qu'un répertoire de modèles existe dans votre répertoire lab_inventory pour organiser vos modèles.
-Ensuite, nous avons besoin d'un playbook pour utiliser ce modèle. Dans le répertoire `~/ansible-files/` créez le Playbook `motd-facts.yml`:
-```yaml
----
-- name: Fill motd file with host data
- hosts: node1
- become: true
- tasks:
- - template:
- src: motd-facts.j2
- dest: /etc/motd
- owner: root
- group: root
- mode: 0644
+```bash
+mkdir -p ~/lab_inventory/templates
```
-Vous l'avez déjà fait plusieurs fois:
-
- - Comprenez ce que fait le Playbook.
+#### Développement du Modèle MOTD :
- - Exécutez le Playbook `motd-facts.yml`.
+Créez un fichier nommé `motd.j2` dans le répertoire des modèles avec le contenu suivant :
- - Connectez-vous à `node1` via SSH et vérifiez le contenu du message du jour.
-
- - Déconnectez-vous de `node1`.
-
-Vous devriez voir comment Ansible remplace les variables par les faits qu'il a découverts dans le système.
+```jinja
+Bienvenue sur {{ ansible_hostname }}.
+OS : {{ ansible_distribution }} {{ ansible_distribution_version }}
+Architecture : {{ ansible_architecture }}
+```
-## Étape 2 - Défi: Les templates
+Ce modèle affiche dynamiquement le nom d'hôte, la distribution de l'OS, la version et l'architecture de chaque hôte géré.
-Ajoutez une ligne au template pour afficher le noyau utilisé du nœud géré.
+### Étape 3 - Déploiement du Modèle avec un Playbook
- - Trouvez un fait qui contient la version du noyau en utilisant les commandes que vous avez apprises dans le chapitre sur les "faits".
+Utilisez le module `ansible.builtin.template` dans un playbook pour distribuer et rendre le modèle sur vos hôtes gérés.
-> **Astuce**
->
-> Faites un `grep -i` pour le noyau
+Modifiez le playbook `system_setup.yml` avec le contenu suivant :
- - Modifiez le modèle pour utiliser le fait que vous avez trouvé.
+```yaml
+---
+- name: Configuration Système de Base
+ hosts: all
+ become: true
+ tasks:
+ - name: Mise à jour de MOTD à partir du modèle Jinja2
+ ansible.builtin.template:
+ src: templates/motd.j2
+ dest: /etc/motd
- - Exécutez à nouveau le Playbook.
+ handlers:
+ - name: Recharger le Pare-feu
+ ansible.builtin.service:
+ name: firewalld
+ state: reloaded
+```
- - Vérifiez motd en vous connectant à node1
+Le module `ansible.builtin.template` prend le modèle `motd.j2` et génère un fichier `/etc/motd` sur chaque hôte, en remplissant les espaces réservés du modèle avec les faits réels de l'hôte.
-> **Avertissement**
->
-> **Solution ci-dessous \!**
+### Étape 4 - Exécution du Playbook
+Exécutez le playbook pour appliquer votre MOTD personnalisé sur tous les hôtes gérés :
- - Trouvez le fait:
```bash
-[student@ansible ansible-files]$ ansible node1 -m setup|grep -i kernel
- "ansible_kernel": "3.10.0-693.el7.x86_64",
+[student@ansible-1 lab_inventory]$ ansible-navigator run system_setup.yml -m stdout
```
- - Modifiez le template `motd-facts.j2`:
-
-```html+jinja
-Welcome to {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-deployed on {{ ansible_architecture }} architecture
-running kernel {{ ansible_kernel }}.
+```plaintext
+PLAY [Configuration Système de Base] *******************************************
+.
+.
+.
+
+TASK [Mise à jour de MOTD à partir du modèle Jinja2] ***************************
+changed: [node1]
+changed: [node2]
+changed: [node3]
+changed: [ansible-1]
+
+RECAP *************************************************************************
+ansible-1 : ok=6 changed=1 unreachable=0 failed=0 skipped=2 rescued=0 ignored=0
+node1 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node2 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node3 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
```
-
- - Executez le playbook.
-```
-[student1@ansible ~]$ ansible-playbook motd-facts.yml
-```
+Vérifiez les changements en vous connectant au nœud via SSH, et vous devriez voir le message du jour:
- - Vérifiez le nouveau message via la connexion SSH pour `node1`.
-```
-[student1@ansible ~]$ ssh node1
-Welcome to node1.
-RedHat 8.1
-deployed on x86_64 architecture
-running kernel 4.18.0-147.8.1.el8_1.x86_64.
+```plaintext
+[rhel@control ~]$ ssh node1
+
+Bienvenue sur node1.
+OS : RedHat 8.7
+Architecture : x86_64
+Enregistrez ce système auprès de Red Hat Insights : insights-client --register
+Créez un compte ou consultez tous vos systèmes sur https://red.ht/insights-dashboard
+Dernière connexion : Lun 29 Jan 16:30:31 2024 depuis 10.5.1.29
```
+
----
**Navigation**
[Exercise précédent](../1.5-handlers/README.fr.md) - [Exercise suivant](../1.7-role/README.fr.md)
[Cliquez ici pour revenir à l'atelier Ansible pour Red Hat Enterprise Linux](../README.fr.md)
+
+
diff --git a/exercises/ansible_rhel/1.6-templates/README.ja.md b/exercises/ansible_rhel/1.6-templates/README.ja.md
index 22c5a6fc1..9c7d2f0c9 100644
--- a/exercises/ansible_rhel/1.6-templates/README.ja.md
+++ b/exercises/ansible_rhel/1.6-templates/README.ja.md
@@ -1,165 +1,122 @@
# ワークショップ演習 - テンプレート
-**他の言語でもお読みいただけます**:
-
 [English](README.md)、[日本語](README.ja.md)、 [Portugues do Brasil](README.pt-br.md)、 [Française](README.fr.md)、 [Español](README.es.md)
+**他の言語で読む**:
+
 [英語](README.md),  [日本語](README.ja.md),  [ブラジルポルトガル語](README.pt-br.md),  [フランス語](README.fr.md),  [スペイン語](README.es.md).
## 目次
-* [目的](#目的)
-* [ガイド](#ガイド)
- * [ステップ 1 - Playbooks でのテンプレートの使用](#ステップ-1---playbooks-でのテンプレートの使用)
- * [ステップ 2 - チャレンジラボ](#ステップ-2---チャレンジラボ)
+- [目的](#目的)
+- [ガイド](#ガイド)
+ - [ステップ 1 - Jinja2 テンプレーティングへの導入](#ステップ-1---jinja2-テンプレーティングへの導入)
+ - [ステップ 2 - はじめてのテンプレートを作成する](#ステップ-2---はじめてのテンプレートを作成する)
+ - [ステップ 3 - プレイブックでテンプレートを展開する](#ステップ-3---プレイブックでテンプレートを展開する)
+ - [ステップ 4 - プレイブックを実行する](#ステップ-4---プレイブックを実行する)
## 目的
-この演習では、Jinja2 テンプレートについて説明します。Ansible は Jinja2 テンプレートを使用して、ファイルが管理対象ホストに配布される前にファイルを変更します。Jinja2は、Python で最も使用されているテンプレートエンジンの1つです ()。
+演習 1.5 では、Ansible 内での Jinja2 テンプレーティングが紹介されます。これは、テンプレートから動的なファイルを生成するための強力な機能です。ホスト固有のデータを組み込んだテンプレートを作成する方法を学び、管理されている各ホストに合わせた設定ファイルを作成できるようになります。
## ガイド
-### ステップ 1 - Playbooks でのテンプレートの使用
+### ステップ 1 - Jinja2 テンプレーティングへの導入
-ファイルのテンプレートが作成されると、`template` モジュールを使用して管理対象ホストに展開できます。これは、制御ノードから管理対象ホストへのローカルファイルの転送に対応しています。
+Ansible は Jinja2 を活用しています。Jinja2 は Python 用の広く使用されているテンプレート言語で、ファイル内で動的なコンテンツの生成を可能にします。この機能は、ホストごとに異なる必要がある設定ファイルを構成する場合に特に便利です。
-テンプレートの使用例として、ホスト固有のデータを含むように motd ファイルを変更します。
+### ステップ 2 - はじめてのテンプレートを作成する
-最初に、テンプレートリソースを保持するディレクトリー `templates` を `~/ansible-files/` に作成します。
+テンプレートは `.j2` 拡張子で終わり、静的なコンテンツと `{{ }}` で囲まれた動的なプレースホルダーを混在させます。
-```bash
-[student@ansible-1 ansible-files]$ mkdir templates
-```
+次の例では、動的なホスト情報を含む「本日のメッセージ」(MOTD) のテンプレートを作成しましょう。
-その後、`~/ansible-files/templates/` ディレクトリーに、テンプレートファイル `motd-facts.j2` を作成します。
+#### テンプレートディレクトリの設定:
-
+テンプレートを整理するために、lab_inventory ディレクトリ内にテンプレートディレクトリが存在することを確認してください。
-```html+jinja
-Welcome to {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-deployed on {{ ansible_architecture }} architecture.
+```bash
+mkdir -p ~/lab_inventory/templates
```
-
+#### MOTD テンプレートの開発:
-このテンプレートファイルには、後でコピーされる基本的なテキストが含まれています。また、ターゲットマシンで個別に置き換えられる変数も含まれています。
+テンプレートディレクトリに `motd.j2` という名前のファイルを作成し、以下の内容を含めます:
-次に、このテンプレートを使用するための Playbook が必要です。`~/ansible-files/` ディレクトリーで、Playbook `motd-facts.yml` を作成します。
-
-```yaml
----
-- name: Fill motd file with host data
- hosts: node1
- become: true
- tasks:
- - template:
- src: motd-facts.j2
- dest: /etc/motd
- owner: root
- group: root
- mode: 0644
+```jinja
+{{ ansible_hostname }} へようこそ。
+OS: {{ ansible_distribution }} {{ ansible_distribution_version }}
+アーキテクチャ: {{ ansible_architecture }}
```
-この操作はこれまで数回行ってきました。
-
-* Playbook の内容を把握します。
-* Playbook `motd-facts.yml` を実行します。
-* SSH 経由で node1 にログインし、その日の内容のメッセージを確認します。
-* node1 からログアウトします。
-
-Ansible がシステムから検出したファクトに変数置き換える方法を確認してください。
-
-### ステップ 2 - チャレンジラボ
-
-テンプレートに行を追加して、管理対象ノードの現在のカーネルを一覧表示します。
-
-* 「Ansible ファクト」の章で学習したコマンドを使用して、カーネルバージョンを含むファクトを見つけます。
-
-> *ヒント**
->
-> カーネルのフィルター
-
-> 新規作成された Playbook を実行してファクト名を検索します。
-
-* テンプレートを変更して、見つけたファクトを使用します。
+このテンプレートは、管理されている各ホストのホスト名、OS の配布、バージョン、およびアーキテクチャを動的に表示します。
-* 再び motd Playbook を実行します。
+### ステップ 3 - プレイブックでテンプレートを展開する
-* node1 にログインして motd を確認します
+プレイブック内で `ansible.builtin.template` モジュールを使用して、管理されているホストにテンプレートを配布し、レンダリングします。
-> **警告**
->
-> **回答を以下に示します。**
-
-* ファクトを見つけます。
+以下の内容で `system_setup.yml` プレイブックを変更します:
```yaml
---
-- name: Capture Kernel Version
- hosts: node1
-
+- name: 基本的なシステムセットアップ
+ hosts: all
+ become: true
tasks:
+ - name: Jinja2 テンプレートから MOTD を更新
+ ansible.builtin.template:
+ src: templates/motd.j2
+ dest: /etc/motd
- - name: Collect only kernel facts
- ansible.builtin.setup:
- filter:
- - '*kernel'
- register: setup
-
- - debug:
- var: setup
-```
-
-ワイルドカードが導入されると、出力は以下のようになります。
-
-```bash
-
-TASK [debug] *******************************************************************
-ok: [node1] => {
- "setup": {
- "ansible_facts": {
- "ansible_kernel": "4.18.0-305.12.1.el8_4.x86_64"
- },
- "changed": false,
- "failed": false
- }
-}
+ handlers:
+ - name: ファイアウォールの再読み込み
+ ansible.builtin.service:
+ name: firewalld
+ state: reloaded
```
-これにより、検索する変数に `ansible_kernel` というラベルが付けられます。
+`ansible.builtin.template` モジュールは `motd.j2` テンプレートを取り、各ホストに `/etc/motd` ファイルを生成し、テンプレートのプレースホルダーを実際のホストの事実で埋めます。
-次に、motd-facts.j2 テンプレートを更新して、メッセージの一部として `ansible_kernel` を含めることができます。
+### ステップ 4 - プレイブックを実行する
-* テンプレート `motd-facts.j2` 変更します。
+管理されているすべてのホストにカスタム MOTD を適用するために、プレイブックを実行します:
-
+```bash
+[student@ansible-1 lab_inventory]$ ansible-navigator run system_setup.yml -m stdout
+```
-```html+jinja
-Welcome to {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-deployed on {{ ansible_architecture }} architecture
-running kernel {{ ansible_kernel }}.
+```plaintext
+PLAY [基本的なシステムセットアップ] *********************************************
+.
+.
+.
+
+TASK [Jinja2 テンプレートから MOTD を更新] **************************************
+changed: [node1]
+changed: [node2]
+changed: [node3]
+changed: [ansible-1]
+
+RECAP ************************************************************************
+ansible-1 : ok=6 changed=1 unreachable=0 failed=0 skipped=2 rescued=0 ignored=0
+node1 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node2 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node3 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
```
-
+ ノードにSSHで接続して変更を確認し、その日のメッセージが表示されるはずです：
-* Playbook を実行します。
+```plaintext
+[rhel@control ~]$ ssh node1
-```bash
-[student@ansible-1 ~]$ ansible-navigator run motd-facts.yml -m stdout
+node1 へようこそ。
+OS: RedHat 8.7
+アーキテクチャ: x86_64
+このシステムを Red Hat Insights に登録する：insights-client --register
+アカウントを作成するか、https://red.ht/insights-dashboard で全てのシステムを表示する
+最終ログイン：2024年1月29日 月曜日 16:30:31 から 10.5.1.29
```
-* `node1` への SSH ログインを介して新しいメッセージを確認します。
-
-```bash
-[student@ansible-1 ~]$ ssh node1
-Welcome to node1.
-RedHat 8.1
-deployed on x86_64 architecture
-running kernel 4.18.0-305.12.1.el8_4.x86_64.
-```
---
**ナビゲーション**
-[前の演習](../1.5-handlers) - [次の演習](../1.7-role)
+[前の演習](../1.5-handlers/README.ja.md) - [次の演習](../1.7-role/README.ja.md)
-[Click here to return to the Ansible for Red Hat Enterprise Linux Workshop](../README.md#section-1---ansible-engine-exercises)
diff --git a/exercises/ansible_rhel/1.6-templates/README.pt-br.md b/exercises/ansible_rhel/1.6-templates/README.pt-br.md
index 6fb518f46..7dd9cc4fd 100644
--- a/exercises/ansible_rhel/1.6-templates/README.pt-br.md
+++ b/exercises/ansible_rhel/1.6-templates/README.pt-br.md
@@ -1,101 +1,123 @@
-# Exercicio - Templates
+# Exercício de Workshop - Templates
-**Leia em outras linguagens**:
-
 [English](README.md), [日本語](README.ja.md),  [Portugues do Brasil](README.pt-br.md),  [Française](README.fr.md), [Español](README.es.md).
+**Leia isto em outros idiomas**:
+
 [Inglês](README.md),  [Japonês](README.ja.md),  [Português do Brasil](README.pt-br.md),  [Francês](README.fr.md),  [Espanhol](README.es.md).
-* [Passo 1 - Usando Templates em Playbooks](#passo-1---usando-templates-em-playbooks)
-* [Passo 2 - Laboratório de Desafios](#passo-2---laboratório-de-desafios)
+## Índice
-O Ansible usa o template Jinja2 para modificar arquivos antes de serem distribuídos para hosts gerenciados. O Jinja2 é um dos mecanismos de template mais usados para o Python ().
+- [Objetivo](#objetivo)
+- [Guia](#guia)
+ - [Passo 1 - Introdução ao Templating Jinja2](#passo-1---introdução-ao-templating-jinja2)
+ - [Passo 2 - Criando Seu Primeiro Template](#passo-2---criando-seu-primeiro-template)
+ - [Passo 3 - Implementando o Template com um Playbook](#passo-3---implementando-o-template-com-um-playbook)
+ - [Passo 4 - Executando o Playbook](#passo-4---executando-o-playbook)
-## Passo 1 - Usando Templates em Playbooks
+## Objetivo
-Quando um template é criado, ele pode ser implantado nos hosts gerenciados usando o módulo `template`, que suporta a transferência de um arquivo local do nó de controle para os hosts gerenciados.
+O Exercício 1.5 introduz o templating Jinja2 dentro do Ansible, um recurso poderoso para gerar arquivos dinâmicos a partir de templates. Você aprenderá como criar templates que incorporam dados específicos do host, permitindo a criação de arquivos de configuração personalizados para cada host gerenciado.
-Como exemplo de uso de templates, você irá alterar o arquivo motd para conter dados específicos do host.
+## Guia
+### Passo 1 - Introdução ao Templating Jinja2
-No diretório `~/ansible-files/` crie o arquivo de template `motd-facts.j2`:
+O Ansible utiliza o Jinja2, uma linguagem de templating amplamente usada para Python, permitindo a geração de conteúdo dinâmico dentro dos arquivos. Essa capacidade é particularmente útil para configurar arquivos que devem variar de host para host.
-
-```html+jinja
-Bem vindo ao {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-implementado na arquitetura {{ ansible_architecture }}.
-```
-
-
-O arquivo de template contém o texto básico que mais tarde será copiado. Ele também contém variáveis que serão substituídas nas máquinas de destino individualmente.
-
-Em seguida, precisamos de um Playbook para usar este modelo. No diretório `~/ansible-files/` crie o Playbook `motd-facts.yml`:
+### Passo 2 - Criando Seu Primeiro Template
-```yaml
----
-- name: Preencher arquivo motd com dados do host
- hosts: node1
- become: yes
- tasks:
- - template:
- src: motd-facts.j2
- dest: /etc/motd
- owner: root
- group: root
- mode: 0644
-```
+Os templates terminam com a extensão `.j2` e misturam conteúdo estático com espaços reservados dinâmicos envolvidos em `{{ }}`.
-Você já fez isso algumas vezes até agora:
+No exemplo a seguir, vamos criar um template para a Mensagem do Dia (MOTD) que inclui informações dinâmicas do host.
- - Entender o que o Playbook faz.
+#### Configurando o Diretório de Templates:
- - Executar o Playbook `motd-facts.yml`.
+Certifique-se de que um diretório de templates exista dentro do seu diretório lab_inventory para organizar seus templates.
- - Efetue login no node1 via SSH e verifique a mensagem do conteúdo do dia.
+```bash
+mkdir -p ~/lab_inventory/templates
+```
- - Efetue Logout no node1.
+#### Desenvolvendo o Template MOTD:
-Você deve ter visto como o Ansible substitui as variáveis pelos dados descobertos no sistema.
+Crie um arquivo chamado `motd.j2` no diretório de templates com o seguinte conteúdo:
-## Passo 2 - Laboratório de Desafios
+```jinja
+Bem-vindo ao {{ ansible_hostname }}.
+SO: {{ ansible_distribution }} {{ ansible_distribution_version }}
+Arquitetura: {{ ansible_architecture }}
+```
-Adicione uma linha ao template para listar o kernel atual do nó gerenciado.
+Este template exibe dinamicamente o nome do host, a distribuição do sistema operacional, a versão e a arquitetura de cada host gerenciado.
- - Encontre um fact que contenha a versão do kernel usando os comandos que você aprendeu no capítulo "Ansible Facts".
+### Passo 3 - Implementando o Template com um Playbook
-> **Dica**
->
-> Use `grep -i` para o kernel
+Utilize o módulo `ansible.builtin.template` em um playbook para distribuir e renderizar o template em seus hosts gerenciados.
- - Mude o template para usar o fact que você encontrou.
+Modifique o playbook `system_setup.yml` com o seguinte conteúdo:
- - Execute o Playbook novamente.
+```yaml
+---
+- name: Configuração Básica do Sistema
+ hosts: all
+ become: true
+ tasks:
+ - name: Atualizar MOTD a partir do Template Jinja2
+ ansible.builtin.template:
+ src: templates/motd.j2
+ dest: /etc/motd
- - Verifique o motd efetuando login no node1
+ handlers:
+ - name: Recarregar Firewall
+ ansible.builtin.service:
+ name: firewalld
+ state: reloaded
+```
-> **ATENÇÃO**
->
-> **Solução abaixo\!**
+O módulo `ansible.builtin.template` pega o template `motd.j2` e gera um arquivo `/etc/motd` em cada host, preenchendo os espaços reservados do template com os fatos reais do host.
+### Passo 4 - Executando o Playbook
- - Procure o fact:
+Execute o playbook para aplicar seu MOTD personalizado em todos os hosts gerenciados:
```bash
-[student@ansible ansible-files]$ ansible node1 -m setup|grep -i kernel
- "ansible_kernel": "3.10.0-693.el7.x86_64",
+[student@ansible-1 lab_inventory]$ ansible-navigator run system_setup.yml -m stdout
+```
+
+```plaintext
+PLAY [Configuração Básica do Sistema] *****************************************
+.
+.
+.
+
+TASK [Atualizar MOTD a partir do Template Jinja2] *****************************
+changed: [node1]
+changed: [node2]
+changed: [node3]
+changed: [ansible-1]
+
+RECAP ************************************************************************
+ansible-1 : ok=6 changed=1 unreachable=0 failed=0 skipped=2 rescued=0 ignored=0
+node1 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node2 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
+node3 : ok=8 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
```
- - Modifique o template `motd-facts.j2`:
+Verifique as alterações fazendo SSH para o nó, e você deverá ver a mensagem do dia:
-
-```html+jinja
-Bem vindo ao {{ ansible_hostname }}.
-{{ ansible_distribution }} {{ ansible_distribution_version}}
-implementado na arquitetura {{ ansible_architecture }}
-executando o kernel {{ ansible_kernel }}.
+```plaintext
+[rhel@control ~]$ ssh node1
+
+Bem-vindo ao node1.
+SO: RedHat 8.7
+Arquitetura: x86_64
+Registre este sistema no Red Hat Insights: insights-client --register
+Crie uma conta ou visualize todos os seus sistemas em https://red.ht/insights-dashboard
+Último login: Seg Jan 29 16:30:31 2024 de 10.5.1.29
```
-
- - Execute o playbook.
- - Verifique a nova mensagem via login SSH no `node1`.
----
+**Navegação**
+
+[Exercício anterior](../1.5-handlers/README.pt-br.md) - [Próximo exercício](../1.7-role/README.pt-br.md)
+
+[Clique aqui para voltar ao workshop de Ansible para Red Hat Enterprise Linux](../README.md)
-[Clique aqui para retornar ao Workshop Ansible for Red Hat Enterprise Linux](../README.pt-br.md#seção-1---exercícios-do-ansible-engine)