Red Hat Summit Red Hat SummitSupportoConsoleSviluppatoriInizia una provaContatti

Questo contenuto non è disponibile nella lingua selezionata.

Chapter 14. Usage reporting with metrics-utility

The Ansible Automation Platform metrics utility tool (metrics-utility) is a command-line utility that is installed on a system containing an instance of automation controller.

When installed and configured, metrics-utility gathers billing-related metrics from your system and creates a consumption-based billing report. metrics-utility is especially suited for users who have multiple managed hosts and want to use consumption-based billing. Once a report is generated, it is deposited in a target location that you specify in the configuration file.

metrics-utility collects two types of data from your system: configuration data and reporting data.

The configuration data includes the following information:

  • Version information for automation controller and for the operating system
  • Subscription information
  • The base URL

The reporting data includes the following information:

  • Job name and ID
  • Host name
  • Inventory name
  • Organization name
  • Project name
  • Success or failure information
  • Report date and time

To ensure that metrics-utility continues to work as configured, clear your report directories of outdated reports regularly.

14.1. Configuring metrics-utility
Copia collegamento

Configure the metrics-utility to gather and report usage data for your Ansible Automation Platform, both on Red Hat Enterprise Linux and OpenShift Container Platform.

14.1.1. Configuring metrics-utility on Red Hat Enterprise Linux
Copia collegamento

Prerequisites:

  • An active Ansible Automation Platform subscription

metrics-utility is included with Ansible Automation Platform, so you do not need a separate installation. The following commands gather the relevant data and generate a CCSP report containing your usage metrics. You can configure these commands as cronjobs to ensure they run at the beginning of every month. See How to schedule jobs using the Linux 'cron' utility for more on configuring using the cron syntax.

Procedure

  1. Create two scripts in your user’s home directory in order to set correct variables to ensure that metrics-utility gathers all relevant data:

    1. In /home/my-user/cron-gather: 

      #!/bin/sh

# Specify the following variables to indicate where the report is deposited in your file system:
export METRICS_UTILITY_SHIP_TARGET=directory
export METRICS_UTILITY_SHIP_PATH=/awx_devel/awx-dev/metrics-utility/shipped_data/billing

# Run the following command to gather and store the data in the provided SHIP_PATH directory:
metrics-utility gather_automation_controller_billing_data --ship --until=10m
      Copy to Clipboard Toggle word wrap

    2. In /home/my-user/cron-report: 

      #!/bin/sh

# Specify the following variables to indicate where the report is deposited in your file system:
export METRICS_UTILITY_SHIP_TARGET=directory
export METRICS_UTILITY_SHIP_PATH=/awx_devel/awx-dev/metrics-utility/shipped_data/billing

# Set these variables to generate a report:
export METRICS_UTILITY_REPORT_TYPE=CCSPv2
export METRICS_UTILITY_PRICE_PER_NODE=11.55 # in USD
export METRICS_UTILITY_REPORT_SKU=MCT3752MO
export METRICS_UTILITY_REPORT_SKU_DESCRIPTION="EX: Red Hat Ansible Automation Platform, Full Support (1 Managed Node, Dedicated, Monthly)"
@@ -44,21 +51,31 @@ export METRICS_UTILITY_REPORT_EMAIL="email@email.com"
export METRICS_UTILITY_REPORT_RHN_LOGIN="test_login"
export METRICS_UTILITY_REPORT_COMPANY_BUSINESS_LEADER="BUSINESS LEADER"
export METRICS_UTILITY_REPORT_COMPANY_PROCUREMENT_LEADER="PROCUREMENT LEADER"

# Build the report
metrics-utility build_report
      Copy to Clipboard Toggle word wrap

  2. To ensure that these files are executable, run: 

    chmod a+x /home/my-user/cron-gather /home/my-user/cron-report
    Copy to Clipboard Toggle word wrap

  3. To open the cron file for editing, run: 

    crontab -e
    Copy to Clipboard Toggle word wrap

  4. To configure the run schedule, add the following parameters to the end of the file and specify how often you want metrics-utility to gather information and build a report using the cron syntax. In the following example, the gather command is configured to run every hour at 00 minutes. The build_report command is configured to run on the second day of each month at 4:00 AM. 

    0 */1 * * * /home/my-user/cron-gather
0 4 2 * * /home/my-user/cron-report
    Copy to Clipboard Toggle word wrap
  5. Save and close the file.

  6. To verify that you saved your changes, run: 

    crontab -l
    Copy to Clipboard Toggle word wrap

  7. To ensure that data is being collected, run: 

    cat /var/log/cron
    Copy to Clipboard Toggle word wrap

    The following is an example of the output. Note that time and date might vary depending on how your configure the run schedule: 

    May  8 09:45:03 ip-10-0-6-23 CROND[51623]: (root) CMDOUT (No billing data for month: 2024-04)
May  8 09:45:03 ip-10-0-6-23 CROND[51623]: (root) CMDEND (metrics-utility build_report)
May  8 09:45:19 ip-10-0-6-23 crontab[51619]: (root) END EDIT (root)
May  8 09:45:34 ip-10-0-6-23 crontab[51659]: (root) BEGIN EDIT (root)
May  8 09:46:01 ip-10-0-6-23 CROND[51688]: (root) CMD (metrics-utility gather_automation_controller_billing_data --ship --until=10m)
May  8 09:46:03 ip-10-0-6-23 CROND[51669]: (root) CMDOUT (/tmp/9e3f86ee-c92e-4b05-8217-72c496e6ffd9-2024-05-08-093402+0000-2024-05-08-093602+0000-0.tar.gz)
May  8 09:46:03 ip-10-0-6-23 CROND[51669]: (root) CMDEND (metrics-utility gather_automation_controller_billing_data --ship --until=10m)
May  8 09:46:26 ip-10-0-6-23 crontab[51659]: (root) END EDIT (root)
    Copy to Clipboard Toggle word wrap

    The generated report will have the default name CCSP-<YEAR>-<MONTH>.xlsx and will be deposited in the ship path that you specified in step 1a.

metrics-utility is included in the OpenShift Container Platform automation controller image for versions 4.12, 4.5.12, and 4.6. If your system does not have metrics-utility installed, update your OpenShift image to the latest version.

Create a ConfigMap in the OpenShift UI YAML view and deploy automation controller to configure the run schedule for metrics-utility on OpenShift Container Platform using the Ansible Automation Platform operator.

Prerequisites:

  • A running OpenShift cluster
  • An operator-based installation of Ansible Automation Platform on OpenShift Container Platform.
Note

metrics-utility will run as indicated by the parameters you set in the configuration file.

14.1.2.1. Create a ConfigMap in the OpenShift UI YAML view
Copia collegamento

To inject the metrics-utility cronjobs with configuration data, use the following procedure to create a ConfigMap in the OpenShift UI YAML view:

  1. From the navigation panel on the left side, select ConfigMaps, and then click the Create ConfigMap button.
  2. On the next screen, select the YAML view tab.

  3. In the YAML field, enter the following parameters with the appropriate variables set: 

    apiVersion: v1
kind: ConfigMap
metadata:
  name: automationcontroller-metrics-utility-configmap
data:
  METRICS_UTILITY_SHIP_TARGET: directory
  METRICS_UTILITY_SHIP_PATH: /metrics-utility
  METRICS_UTILITY_REPORT_TYPE: CCSP
  METRICS_UTILITY_PRICE_PER_NODE: '11' # in USD
  METRICS_UTILITY_REPORT_SKU: MCT3752MO
  METRICS_UTILITY_REPORT_SKU_DESCRIPTION: "EX: Red Hat Ansible Automation Platform, Full Support (1 Managed Node, Dedicated, Monthly)"
  METRICS_UTILITY_REPORT_H1_HEADING: "CCSP Reporting <Company>: ANSIBLE Consumption"
  METRICS_UTILITY_REPORT_COMPANY_NAME: "Company Name"
  METRICS_UTILITY_REPORT_EMAIL: "email@email.com"
  METRICS_UTILITY_REPORT_RHN_LOGIN: "test_login"
  METRICS_UTILITY_REPORT_COMPANY_BUSINESS_LEADER: "BUSINESS LEADER"
  METRICS_UTILITY_REPORT_COMPANY_PROCUREMENT_LEADER: "PROCUREMENT LEADER"
    Copy to Clipboard Toggle word wrap
  4. Click Create.
  5. To verify that the ConfigMap was created and the metric utility is installed, select ConfigMap from the navigation panel and look for your ConfigMap in the list.

14.1.2.2. Deploy automation controller
Copia collegamento

To deploy automation controller and specify variables for how often metrics-utility gathers usage information and generates a report, use the following procedure:

Procedure

  1. From the navigation panel, select Installed Operators.
  2. Select Ansible Automation Platform.
  3. In the Operator details, select the automation controller tab.
  4. Click Create automation controller*.

  5. Select the YAML view option. The YAML now shows the default parameters for automation controller. The relevant parameters for metrics-utility are the following: 

    [cols="50%,50%",options="header"]
|====
| *Parameter* | *Variable*
| *`metrics_utility_enabled`* | True.
| *`metrics_utility_cronjob_gather_schedule`* | @hourly or @daily.
| *`metrics_utility_cronjob_report_schedule`* | @daily or @monthly.
|====
    Copy to Clipboard Toggle word wrap
  6. Find the metrics_utility_enabled parameter and change the variable to true.
  7. Find the metrics_utility_cronjob_gather_schedule parameter and enter a variable for how often the utility should gather usage information (for example, @hourly or @daily).
  8. Find the metrics_utility_cronjob_report_schedule parameter and enter a variable for how often the utility generates a report (for example, @daily or @monthly).
  9. Click Create.

14.2. Fetching a monthly report
Copia collegamento

Fetch a monthly report from Ansible Automation Platform to gather usage metrics and create a consumption-based billing report. To fetch a monthly report on Red Hat Enterprise Linux or on OpenShift Container Platform, use the following procedures:

14.2.1. Fetching a monthly report on Red Hat Enterprise Linux
Copia collegamento

Use the following procedure to fetch a monthly report on Red Hat Enterprise Linux:

Procedure

  1. Run: 
scp -r username@controller_host:$METRICS_UTILITY_SHIP_PATH/data/<YYYY>/<MM>/ /local/directory/
Copy to Clipboard Toggle word wrap

The generated report will have the default name CCSP-<YEAR>-<MONTH>.xlsx and will be deposited in the ship path that you specified.

Use the following playbook to fetch a monthly consumption report for Ansible Automation Platform on OpenShift Container Platform: 

- name: Copy directory from Kubernetes PVC to local machine
  hosts: localhost

  vars:
    report_dir_path: "/mnt/metrics/reports/{{ year }}/{{ month }}/"

  tasks:
    - name: Create a temporary pod to access PVC data
      kubernetes.core.k8s:
        definition:
          apiVersion: v1
          kind: Pod
          metadata:
            name: temp-pod
            namespace: "{{ namespace_name }}"
          spec:
            containers:
            - name: busybox
              image: busybox
              command: ["/bin/sh"]
              args: ["-c", "sleep 3600"]  # Keeps the container alive for 1 hour
              volumeMounts:
              - name: "{{ pvc }}"
                mountPath: "/mnt/metrics"
            volumes:
            - name: "{{ pvc }}"
              persistentVolumeClaim:
                claimName: automationcontroller-metrics-utility
            restartPolicy: Never
      register: pod_creation

    - name: Wait for both initContainer and main container to be ready
      kubernetes.core.k8s_info:
        kind: Pod
        namespace: "{{ namespace_name }}"
        name: temp-pod
      register: pod_status
      until: >
        pod_status.resources[0].status.containerStatuses[0].ready
      retries: 30
      delay: 10

    - name: Create a tarball of the directory of the report in the container
      kubernetes.core.k8s_exec:
        namespace: "{{ namespace_name }}"
        pod: temp-pod
        container: busybox
        command: tar czf /tmp/metrics.tar.gz -C "{{ report_dir_path }}" .
      register: tarball_creation

    - name: Copy the report tarball from the container to the local machine
      kubernetes.core.k8s_cp:
        namespace: "{{ namespace_name }}"
        pod: temp-pod
        container: busybox
        state: from_pod
        remote_path: /tmp/metrics.tar.gz
        local_path: "{{ local_dir }}/metrics.tar.gz"
      when: tarball_creation is succeeded

    - name: Ensure the local directory exists
      ansible.builtin.file:
        path: "{{ local_dir }}"
        state: directory

    - name: Extract the report tarball on the local machine
      ansible.builtin.unarchive:
        src: "{{ local_dir }}/metrics.tar.gz"
        dest: "{{ local_dir }}"
        remote_src: yes
        extra_opts: "--strip-components=1"
      when: tarball_creation is succeeded

    - name: Delete the temporary pod
      kubernetes.core.k8s:
        api_version: v1
        kind: Pod
        namespace: "{{ namespace_name }}"
        name: temp-pod
        state: absent
Copy to Clipboard Toggle word wrap

14.3. Modifying the run schedule
Copia collegamento

You can configure metrics-utility to run at specified times and intervals. Run frequency is expressed in cronjobs. For more information on the cron utility, see How to schedule jobs using the Linux ‘Cron’ utility.

To modify the run schedule on Red Hat Enterprise Linux and on OpenShift Container Platform, use one of the following procedures:

14.3.1. Modifying the run schedule on Red Hat Enterprise Linux
Copia collegamento

Use the folowing procedure to modify the run schedule on Red Hat Enterprise Linux.

Procedure

  1. From the command line, run: 

    crontab -e
    Copy to Clipboard Toggle word wrap

  2. After the code editor has opened, update the gather and build parameters using cron syntax as shown below: 

    0 */1 * * * /home/my-user/cron-gather
0 4 2 * * /home/my-user/cron-report
    Copy to Clipboard Toggle word wrap
  3. Save and close the file.

Use the following procedure to adjust the execution schedule of the metrics-utility within your Ansible Automation Platform deployment running on OpenShift Container Platform:

Procedure

  1. From the navigation panel, select Workloads Deployments.
  2. On the next screen, select automation-controller-operator-controller-manager.
  3. Beneath the heading Deployment Details, click the down arrow button to change the number of pods to zero. This will pause the deployment so you can update the running schedule.
  4. From the navigation panel, select Installed Operators.
  5. From the list of installed operators, select Ansible Automation Platform.
  6. On the next screen, select the automation controller tab.
  7. From the list that appears, select your automation controller instance.
  8. On the next screen, select the YAML tab.

  9. In the YAML file, find the following parameters and enter a variable representing how often metrics-utility should gather data and how often it should produce a report: 

    metrics_utility_cronjob_gather_schedule:
metrics_utility_cronjob_report_schedule:
    Copy to Clipboard Toggle word wrap
  10. Click Save.
  11. From the navigation menu, select Deployments and then select automation-controller-operator-controller-manager.
  12. Increase the number of pods to 1.

  13. To verify that you have changed the metrics-utility running schedule successfully, you can take one or both of the following steps:

    1. return to the YAML file and ensure that the parameters described above reflect the correct variables.
    2. From the navigation menu, select Workloads Cronjobs and ensure that your cronjobs show the updated schedule.
Torna in cima
Red Hat logoGithubredditYoutubeTwitter

Formazione

Prova, acquista e vendi

Community

Informazioni sulla documentazione di Red Hat

Aiutiamo gli utenti Red Hat a innovarsi e raggiungere i propri obiettivi con i nostri prodotti e servizi grazie a contenuti di cui possono fidarsi. Esplora i nostri ultimi aggiornamenti.

Rendiamo l’open source più inclusivo

Red Hat si impegna a sostituire il linguaggio problematico nel codice, nella documentazione e nelle proprietà web. Per maggiori dettagli, visita il Blog di Red Hat.

Informazioni su Red Hat

Forniamo soluzioni consolidate che rendono più semplice per le aziende lavorare su piattaforme e ambienti diversi, dal datacenter centrale all'edge della rete.

Theme

© 2025 Red Hat