How can I automate adding the Chef Infra Server view to the Chef Automate UI?

The Chef Infra Server page (Infrastructure > Chef Servers) lets you connect existing Chef Infra Servers to Chef Automate, view all the connected Chef Infra Servers, and manage all the objects on your connected Chef Infra Servers.
 

Currently, connecting Chef Infra Servers to Chef Automate is a manual process. It involves navigating through the GUI and entering required details such as the Infra Server name, organization names, the FQDN of the Chef Infra Server, the admin username, and the associated PEM key.

This process can be automated using the bash script provided below.

Prerequisites:
 

1. Create an Admin token for your Chef Automate instance. This token is essential for the script to authenticate with Chef Automate API. The token is not stored for security reasons and must be provided as a mandatory argument when running the bash script. You can create the token by following the instructions in Creating an API Token.

2. Create a serverConfig.json file and make it accessible to the script. Ensure that the file has appropriate permissions to be read by the script. While the configuration file can have any name, ensure the bash script is updated accordingly. Below is a sample serverConfig.json file. The orgs field is an array, which allows you to specify multiple organisations and add them to your Chef Infra Server.

 

{
  "automateFQDN": "https://ec2-x-x-x-x.compute-1.amazonaws.com"",
  "infraServerFQDN": "https://ec2-x-x-x-x.compute-1.amazonaws.com"",
  "infraServerId": "APIInfraServerAPI",
  "infraServerName": "APIInfraServerAPI",
  "orgs": [
    {
      "adminUserPemFilePath": "Path/to/key.pem",
      "adminUser": "testuser",
      "orgID": "chef_standalone",
      "orgName": "chef_standalone"
    }
  ]
}

The Script: 

The bash script includes methods such as usage and validate_fqdn.The usage method displays the correct usage of the script, while the validate_fqdn method validates the FQDNs provided for Chef Infra Server and Chef Automate. These methods are included to provide usage instruction and validations in the script. You can remove these methods to reduce the script's length without affecting its core functionality.

The API token is a mandatory parameter for running the script. The script will display instructions if you do not provide the token and will exit execution.

By default, the script adds the Infra Server and all organizations listed in the orgs array from the configuration file to the Chef Automate UI. If you prefer to add only the Infra Server and skip adding the organizations, use the --n option.

To add both the Infra Server and all organizations to the Chef Automate UI, use the following command:

./addInfraServerOnAutomate.sh --token <valueOfAPITOken>

To add only the Infra Server and skip the organizations, use:

./addInfraServerOnAutomate.sh --token <valueOfAPITOken> --n

The full script is provided below. You can modify and use it manually or integrate it into your pipelines as required.

Note: This script is provided as a reference only and is not maintained by the Progress Chef team.
 

#!/bin/bash

# Function to display usage
usage() {
    echo
    echo "Usage: ./$(basename "$0") --token <TOKEN_VALUE> [--n]"
    echo
    echo "Mandatory parameter: --token <API_TOKEN_VALUE> "
    echo "Optional parameter: --n (Do not add orgs to the Infra server.) "
    echo
    echo "If execution is stuck after printing the Automate FQDN, please correct the FQDN in the config file. "
    exit 0
}

# Function to parse command-line options
parse_options() {
    # Flag to check if help usage needs to be displayed
    display_usage=true
    add_orgs=true

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --token )
                token="$2"
                shift 2
                display_usage=false
                ;;
            --n | --no-orgs )
                echo "No orgs will be added to the Infra server."
                add_orgs=false
                shift
                display_usage=false
                ;;
            -h | --help )
                usage
                ;;
            -* )
                echo "Invalid option: $1"
                usage
                ;;
        esac
    done

    # Display usage message if no valid options provided
    if [ "$display_usage" = true ] && [ "$#" -eq 0 ]; then
        usage
    fi
}

check_config_file() {
    if [ ! -f "serverConfig.json" ]; then
        echo "Error: Config file not found!"
        exit 1
    fi
}


# Function to validate FQDN
validate_fqdn() {
    local fqdn="$1"

    # Check if FQDN is not empty
    if [ -z "$fqdn" ]; then
        echo "Error: FQDN is empty"
        return 1
    fi

    # Check if FQDN length is within limits
    if [ ${#fqdn} -gt 255 ]; then
        echo "Error: FQDN length exceeds maximum limit of 255 characters"
        return 1
    fi

    # Check if FQDN contains at least one period (.)
    if [[ ! "$fqdn" =~ \. ]]; then
        echo "Error: FQDN must contain at least one period (.)"
        return 1
    fi

    # Check if FQDN does not start or end with a period (.)
    if [[ "$fqdn" =~ ^\.|\.$ ]]; then
        echo "Error: FQDN cannot start or end with a period (.)"
        return 1
    fi

    echo "FQDN is valid: $fqdn"
}

# Function to send API request to Infra server
send_api_request() {
    local endpoint="$1"
    local token="$2"
    local json_data="$3"

    curl_output=$(curl --insecure -s -H "api-token: $token" -H "Content-Type: application/json" --data "$json_data" --location "$endpoint")

    # Check if curl request was successful
    if [ $? -ne 0 ]; then
        echo "Error: Failed to send request to $endpoint"
        exit 1
    fi

    # Print response
    echo "Response:"
    echo "$curl_output"
}

# Function to add an Org to the Infra server
add_org() {
    local endpoint="$1"
    local token="$2"
    local infraServerId="$3"
    local admin_key="$4"
    local admin_user="$5"
    local org_id="$6"
    local org_name="$7"

    orgUrl="$endpoint/api/v0/infra/servers/$infraServerId/orgs"

    json_org_data=$(cat <<EOF
    {
        "admin_key": "$admin_key",
        "admin_user": "$admin_user",
        "id" : "$org_id",
        "name": "$org_name",
        "server_id": "$infraServerId"
    }
EOF
)

    send_api_request "$orgUrl" "$token" "$json_org_data"
}

# Main function
main() {
    parse_options "$@"
    check_config_file

    # Read JSON values for Infra Server
    infraServerFQDN=$(jq -r '.infraServerFQDN' serverConfig.json)
    infraServerId=$(jq -r '.infraServerId' serverConfig.json)
    infraServerName=$(jq -r '.infraServerName' serverConfig.json)
    endpoint=$(jq -r '.automateFQDN' serverConfig.json)

    echo "Automate URL: $endpoint/api/v0/infra/servers"
    validate_fqdn "$endpoint"
    validate_fqdn "$infraServerFQDN"

    url="$endpoint/api/v0/infra/servers"

    json_data=$(cat <<EOF
    {
        "fqdn": "$infraServerFQDN",
        "id" : "$infraServerId",
        "name": "$infraServerName"
    }
EOF
)

    send_api_request "$url" "$token" "$json_data"

    if [ "$add_orgs" = true ]; then
        org_count=$(jq '.orgs | length' serverConfig.json)
        for ((i = 0; i < org_count; i++)); do
            org=$(jq -r --argjson i "$i" '.orgs[$i]' serverConfig.json)
            adminUserPemFilePath=$(echo "$org" | jq -r '.adminUserPemFilePath')
            adminUser=$(echo "$org" | jq -r '.adminUser')
            orgID=$(echo "$org" | jq -r '.orgID')
            orgName=$(echo "$org" | jq -r '.orgName')

            pem_file_path=$(echo "$adminUserPemFilePath" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')

            # Check if the file exists
            if [ ! -f "$pem_file_path" ]; then
                echo "File not found at the specified path."
                exit 1
            fi

            # Read the content of the file and assign it to a variable
            file_content=$(<"$pem_file_path")

            # Call the function to escape newline characters
            escaped_json_key=$(awk 'NF {sub(/\r/, ""); printf "%s\\n",$0;}' "$pem_file_path")

            add_org "$endpoint" "$token" "$infraServerId" "$escaped_json_key" "$adminUser" "$orgID" "$orgName"
        done
    fi
}

# Execute the main function with command-line arguments
main "$@"

 

This script is for reference only and is not maintained by the Progress Chef team.