← Cloudflare One / cloudflare-one / networks / connectors / cloudflare-tunnel / deployment-guides

Ansible

Ansible je softwarový nástroj, který umožňuje hromadnou správu infrastruktury. Ansible nevyžaduje agenta, ke svému fungování potřebuje pouze možnost připojit se k cíli přes SSH a mít na cíli nainstalovaný Python.

Ansible spolupracuje s Terraformem a zjednodušuje tak proces nastavení Cloudflare Tunnel. V tomto návodu použijete Terraform k nasazení serveru SSH na Google Cloud a vytvoříte lokálně spravovaný tunel zpřístupní server přes internet. Terraform automaticky spustí Ansible playbook, který nainstaluje a nakonfiguruje cloudflared na serveru.

Předpoklady

Chcete-li dokončit kroky v tomto návodu, budete potřebovat:

Google Cloud Project ↗ a Nainstalované a ověřené GCP CLI ↗.
Základní znalost Terraformu a Nainstalovaný Terraform.
Zóna na Cloudflare.
Token Cloudflare API hodnotou Cloudflare Tunnel a DNS oprávnění.

1. Nainstalujte Ansible

Viz Pokyny k instalaci Ansible ↗.

2. (Volitelné) Vytvořte pár klíčů SSH

Terraform a Ansible vyžadují k připojení k serveru GCP nezašifrovaný SSH klíč. Pokud ještě žádný klíč nemáte, můžete ho vygenerovat následujícím způsobem:

Otevřete terminál a zadejte následující příkaz:

ssh-keygen -t rsa -f ~/.ssh/gcp_ssh -C <username in GCP>

Až budete vyzváni k zadání přístupové fráze, stiskněte Enter klíč dvakrát, čímž pole ponecháte prázdné. Terraform neumí dekódovat šifrované privátní klíče.

Budou vygenerovány dva soubory: gcp_ssh který obsahuje soukromý klíč, a gcp_ssh.pub obsahující veřejný klíč.

3. Vytvořte konfigurační adresář

Vytvořte složku pro konfigurační soubory Terraform a Ansible:
```
mkdir ansible-tunnel
```
Přejděte do nového adresáře:
```
cd ansible-tunnel
```

4. Vytvořte konfigurační soubory Terraform

Definujte vstupní proměnné

Následující proměnné budou předány do konfigurace GCP a Cloudflare.

Ve svém konfiguračním adresáři vytvořte .tf soubor:
```
touch variables.tf
```

Otevřete soubor v textovém editoru a zkopírujte a vložte následující:

# GCP variables
variable "gcp_project_id" {
  description = "Google Cloud Platform (GCP) project ID"
  type        = string
}

variable "zone" {
  description = "Geographical zone for the GCP VM instance"
  type        = string
}

variable "machine_type" {
  description = "Machine type for the GCP VM instance"
  type        = string
}

# Cloudflare variables
variable "cloudflare_zone" {
  description = "Domain used to expose the GCP VM instance to the Internet"
  type        = string
}

variable "cloudflare_zone_id" {
  description = "Zone ID for your domain"
  type        = string
}

variable "cloudflare_account_id" {
  description = "Account ID for your Cloudflare account"
  type        = string
  sensitive   = true
}

variable "cloudflare_email" {
  description = "Email address for your Cloudflare account"
  type        = string
  sensitive   = true
}

variable "cloudflare_token" {
  description = "Cloudflare API token"
  type        = string
  sensitive   = true
}

Přiřaďte hodnoty proměnným

Ve svém konfiguračním adresáři vytvořte .tfvars soubor:
```
touch terraform.tfvars
```
Terraform tyto proměnné automaticky použije, pokud je soubor pojmenován terraform.tfvars, jinak bude nutné soubor s proměnnými předat ručně.

Přidejte následující proměnné do terraform.tfvars. Nezapomeňte upravit příklad podle svých vlastních hodnot.

cloudflare_zone           = "example.com"
cloudflare_zone_id        = "023e105f4ecef8ad9ca31a8372d0c353"
cloudflare_account_id     = "372e67954025e0ba6aaa6d586b9e0b59"
cloudflare_email          = "[email protected]"
cloudflare_token          = "y3AalHS_E7Vabk3c3lX950F90_Xl7YtjSlzyFn_X"
gcp_project_id            = "testvm-123"
zone                      = "us-central1-a"
machine_type              = "e2-medium"

Nakonfigurujte poskytovatele Terraform

Budete muset deklarovat poskytovatelé ↗ použitý k zajištění infrastruktury.

Ve svém konfiguračním adresáři vytvořte .tf soubor:
```
touch providers.tf
```

Přidejte následující poskytovatele do providers.tf. random poskytovatel se používá k vygenerování tajného klíče tunelu.

terraform {
	required_providers {
		cloudflare = {
			source = "cloudflare/cloudflare"
			version = ">= 5.8.2"
		}
		google = {
			source = "hashicorp/google"
		}
	}
	required_version = ">= 1.2"
}

# Providers
provider "cloudflare" {
	api_token    = var.cloudflare_token
}
provider "google" {
	project    = var.gcp_project_id
}
provider "random" {
}

Nakonfigurujte prostředky Cloudflare

Následující konfigurace upraví nastavení ve vašem účtu Cloudflare.

Ve svém konfiguračním adresáři vytvořte .tf soubor:
```
touch Cloudflare-config.tf
```

Přidejte následující prostředky do Cloudflare-config.tf:


# Creates a new remotely-managed tunnel for the GCP VM.
resource "cloudflare_zero_trust_tunnel_cloudflared" "gcp_tunnel" {
	account_id    = var.cloudflare_account_id
	name          = "Ansible GCP tunnel"
	config_src    = "cloudflare"
}

# Reads the token used to run the tunnel on the server.
data "cloudflare_zero_trust_tunnel_cloudflared_token" "gcp_tunnel_token" {
	account_id 	= var.cloudflare_account_id
	tunnel_id 	= cloudflare_zero_trust_tunnel_cloudflared.gcp_tunnel.id
}

# Creates the CNAME record that routes http_app.${var.cloudflare_zone} to the tunnel.
resource "cloudflare_dns_record" "http_app" {
	zone_id = var.cloudflare_zone_id
	name    = "http_app"
	content = "${cloudflare_zero_trust_tunnel_cloudflared.gcp_tunnel.id}.cfargotunnel.com"
	type    = "CNAME"
	ttl     = 1
	proxied = true
}

# Configures tunnel with a published application for clientless access.
resource "cloudflare_zero_trust_tunnel_cloudflared_config" "gcp_tunnel_config" {
	tunnel_id  = cloudflare_zero_trust_tunnel_cloudflared.gcp_tunnel.id
	account_id = var.cloudflare_account_id
	config     = {
		ingress 	= [
			{
				hostname = "http_app.${var.cloudflare_zone}"
				service  = "http://localhost:80"
			},
			{
				service  = "http_status:404"
			}
		]
	}
}

Nakonfigurujte prostředky GCP

Následující konfigurace definuje specifikace virtuálního počítače GCP a instaluje na něj Python3. Díky Python3 může instanci GCP nakonfigurovat Ansible, takže není nutné spouštět spouštěcí skript při spuštění.

Ve svém konfiguračním adresáři vytvořte .tf soubor:
```
touch GCP-config.tf
```

Otevřete soubor v textovém editoru a zkopírujte a vložte následující příklad. Nezapomeňte vložit vlastní uživatelské jméno GCP a pár SSH klíčů.

# Selects the OS for the GCP VM.
data "google_compute_image" "image" {
family  = "ubuntu-2204-lts"
project = "ubuntu-os-cloud"
}

# Sets up a GCP VM instance.
resource "google_compute_instance" "http_server" {
name         = "ansible-inst"
machine_type = var.machine_type
zone         = var.zone
tags         = []
boot_disk {
    initialize_params {
    image = data.google_compute_image.image.self_link
    }
}
network_interface {
    network = "default"
    access_config {
    // Ephemeral IP
    }
}
scheduling {
    preemptible = true
    automatic_restart = false
}

// Installs Python3 on the VM.
provisioner "remote-exec" {
    inline = [
    "sudo apt update", "sudo apt install python3 -y",  "echo Done!"
    ]
    connection {
    host = self.network_interface.0.access_config.0.nat_ip
    user = "<username in GCP>"
    type = "ssh"
    private_key= file("<path to private key>")
    }
}
provisioner "local-exec" {
    // If specifying an SSH key and user, add `--private-key <path to private key> -u var.name`
    command = "ANSIBLE_HOST_KEY_CHECKING=False ansible-playbook -u <username in GCP> --private-key <path to private key> -i ${self.network_interface.0.access_config.0.nat_ip}, playbook.yml"
}

metadata = {
    cf-email     = var.cloudflare_email
    cf-zone      = var.cloudflare_zone
    ssh-keys     = "<username in GCP>:${file("<path to public key>")}"
}
depends_on = [
    local_file.tf_ansible_vars_file
]
}

Export proměnných do Ansible

Následující prostředek Terraform exportuje token tunelu a další proměnné do tf_ansible_vars_file.yml. Ansible použije tunelový token ke konfiguraci a spuštění cloudflared na serveru.

Ve svém konfiguračním adresáři vytvořte nový tf soubor:
```
touch export.tf
```

Zkopírujte a vložte následující obsah do export.tf:

resource "local_file" "tf_ansible_vars_file" {
	content = <<-DOC
		# Ansible vars_file containing variable values from Terraform.
		tunnel_id: ${cloudflare_zero_trust_tunnel_cloudflared.gcp_tunnel.id}
		tunnel_name: ${cloudflare_zero_trust_tunnel_cloudflared.gcp_tunnel.name}
		tunnel_token: ${data.cloudflare_zero_trust_tunnel_cloudflared_token.gcp_tunnel_token.token}
		DOC

	filename = "./tf_ansible_vars_file.yml"
}

5. Vytvořte Ansible playbook

Playbooky Ansible jsou soubory YAML, které deklarují konfiguraci, kterou Ansible nasadí.

Vytvořte nový .yml soubor:
```
touch playbook.yml
```
Otevřete soubor v textovém editoru a zkopírujte a vložte následující obsah:

---
- hosts: all
  become: yes
  # Import tunnel variables into the VM.
  vars_files:
    - ./tf_ansible_vars_file.yml
  # Execute the following commands on the VM.
  tasks:
    - name: Download the cloudflared Linux package.
      shell: wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
    - name: Depackage cloudflared.
      shell: sudo dpkg -i cloudflared-linux-amd64.deb
    - name: Install the tunnel as a systemd service.
      shell: "cloudflared service install {{ tunnel_token }}"
    - name: Start the tunnel.
      systemd:
        name: cloudflared
        state: started
        enabled: true
        masked: no
    - name: Deploy an example Apache web server on port 80.
      shell: apt update && apt -y install apache2
    - name: Edit the default Apache index file.
      copy:
        dest: /var/www/html/index.html
        content: |
          <!DOCTYPE html>
          <html>
          <body>
            <h1>Hello Cloudflare!</h1>
            <p>This page was created for a Cloudflare demo.</p>
          </body>
          </html>

Klíčová slova ↗ definují, jak Ansible provede konfiguraci. Ve výše uvedeném příkladu vars_files klíčové slovo určuje, kde jsou uloženy definice proměnných, a tasks klíčové slovo určuje akce, které Ansible provede.

Moduly ↗ určete, jaké úkoly mají být dokončeny. V tomto příkladu copy modul vytvoří soubor a naplní ho obsahem.

6. Nasaďte konfiguraci

Jakmile vytvoříte konfigurační soubory, můžete je nasadit pomocí Terraformu. Nasazení Ansible probíhá v rámci nasazení Terraformu, když ansible-playbook příkaz spuštěn.

Inicializujte svůj konfigurační adresář:
```
terraform init
```
(Volitelné) Zobrazte náhled všeho, co bude vytvořeno:
```
terraform plan
```
Nasaďte konfiguraci:
```
terraform apply
```

Aktivace instance GCP a tunelu může trvat několik minut. Nový tunel si můžete zobrazit na kartě Cloudflare dashboard v části Zero Trust > Sítě > Connectory > Cloudflare Tunnels.

7. Otestujte připojení

Chcete-li provést test, otevřete prohlížeč a přejděte na http://http_app.<CLOUDFLARE_ZONE>.com (například http_app.example.com). Měli byste vidět Hello Cloudflare! testovací stránka.