Note:

Supervisión de Oracle Cloud Infrastructure Database con PostgreSQL mediante Datadog

Introducción

Oracle Cloud Infrastructure (OCI) es una plataforma en la nube sólida y altamente escalable diseñada para satisfacer las necesidades de las empresas modernas. Ofrece un conjunto completo de servicios para el desarrollo de computación, almacenamiento, redes, bases de datos y aplicaciones, optimizados para el rendimiento, la seguridad y la rentabilidad. OCI es ideal para ejecutar cargas de trabajo tanto nativas en la nube como tradicionales, lo que ofrece a las empresas una infraestructura flexible y fiable.

Datadog es una completa plataforma de análisis y supervisión basada en la nube diseñada para ayudar a las organizaciones a obtener visibilidad integral de su infraestructura, aplicaciones y servicios de TI. Permite la supervisión en tiempo real, la resolución de problemas y la optimización del rendimiento en entornos de nube híbrida dinámicos. Datadog se integra a la perfección con una amplia gama de herramientas, plataformas y servicios, lo que lo convierte en una solución versátil para los modernos equipos de operaciones de TI y DevOps.

En este tutorial se muestra cómo OCI Database con usuarios de PostgreSQL y Datadog puede configurar soluciones eficientes y escalables para transmitir sin problemas métricas de OCI a Datadog mediante OCI Connector Hub y OCI Functions.

Objetivos

Requisitos

Tarea 1: Creación de una cuenta de Datadog

  1. Configure una cuenta en la herramienta de integración de Datadog mediante el sitio web de Datadog. Proporcione los detalles de cuenta necesarios y complete la configuración del agente configurando los valores de entorno adecuados.

  2. Instale el agente de Datadog para recopilar métricas y eventos de OCI Database con PostgreSQL. Para obtener más información sobre la configuración del agente de Datadog, consulte Configuración del agente de Datadog. Para obtener más información sobre la solución de problemas y la depuración en el agente de Datadog, consulte Uso básico del agente de Datadog.

  3. Seleccione OCI como integración y continúe con su instalación. En la siguiente imagen se muestra la instalación posterior de la integración de OCI para Datadog.

    image

  4. Haga clic en Agregar arrendamiento e introduzca la información del OCID de arrendamiento y de la región inicial.

    image

Tarea 2: Creación de recursos de autenticación de Datadog

Cree un usuario de autenticación de Datadog, un grupo y una política en Oracle Cloud Infrastructure (OCI).

  1. Para crear un dominio, vaya a Identidad y cree un dominio denominado DataDog.

  2. Cree un grupo denominado DatadogAuthGroup.

  3. Cree un usuario denominado DatadogAuthUser con su dirección de correo electrónico (el mismo correo electrónico utilizado para conectarse a la herramienta de supervisión de Datadog) y asigne DatadogAuthGroup como grupo.

  4. Copie el OCID de usuario y péguelo en el campo OCID de usuario del mosaico de integración de OCI de Datadog para configurar el OCID de usuario.

  5. Configurar API.

    1. Navega a tu perfil y selecciona tu nombre de usuario.

    2. Navegue hasta Recursos en la esquina inferior izquierda y seleccione Claves de API.

    3. Haga clic en Agregar clave de API, descargue la clave privada y haga clic en Agregar.

    4. Cierre la ventana Vista previa de archivo de configuración. No se necesita ninguna acción.

    5. Copie el valor de Huella y péguelo en el campo Huella del mosaico de integración de OCI de Datadog.

  6. Configure la clave privada.

    1. Abra el archivo de clave privada descargado (.pem) en un editor de texto o utilice un comando de terminal (por ejemplo, cat) para ver su contenido.

    2. Copie toda la clave, incluidas las líneas -----BEGIN PRIVATE KEY----- y -----END PRIVATE KEY-----.

    3. Pegue la clave privada en el campo Clave privada del mosaico de integración de OCI de Datadog.

  7. Cree una política denominada DataDogPolicy en el compartimento postgresqlinteg (raíz).

  8. Utilice el creador de políticas en modo de editor manual para introducir la sentencia de política necesaria.

    Allow group DatadogAuthGroup to read all-resources in tenancy

A continuación se muestra un mosaico de integración de OCI de Datadog de ejemplo después de agregar detalles de arrendamiento y usuario.

image

Tarea 3: Creación de una pila de OCI

image

Navegue a la sección Identidad y cree una pila de políticas en el compartimento raíz. Esto permite a los hubs de conector leer métricas y llamar a funciones con las siguientes sentencias.

Allow dynamic-group DatadogAuthGroup to read metrics in tenancy
Allow dynamic-group DatadogAuthGroup to use fn-function in tenancy
Allow dynamic-group DatadogAuthGroup to use fn-invocation in tenancy

Para configurar políticas de identidad y desplegar pilas de reenvío de métricas en OCI para la integración de Datadog, siga las tareas:

Tarea 3.1: Crear pila de políticas (ORM_policy_stack)

  1. Haga clic en Crear pila de políticas en el mosaico de integración de OCI de Datadog, asegúrese de utilizar el enlace proporcionado, que incluye el script de Terraform necesario y acepte las condiciones de uso de Oracle.

  2. Haga clic en el menú desplegable Directorio de Trabajo y seleccione datadog-oci-orm/policy-setup.

  3. Anule la selección de Usar proveedores personalizados de Terraform.

  4. Introduzca un nombre descriptivo (por ejemplo, datadog-metrics-policy-setup) y seleccione el compartimento para el despliegue.

  5. Haga clic en Siguiente, asigne un nombre al grupo dinámico y a la política (o utilice nombres por defecto), asegúrese de que la región principal del arrendamiento está seleccionada y haga clic en Crear.

Tarea 3.2: Crear pila de reenvío de métricas

Los recursos se despliegan en el compartimento especificado. Asegúrese de que el usuario que ejecuta la pila tenga los derechos de acceso adecuados.

  1. Haga clic en Crear pila de políticas en el mosaico de integración de OCI de Datadog y acepte las condiciones de uso de Oracle.

  2. Haga clic en el menú desplegable Directorio de trabajo, seleccione datadog-oci-orm/metrics-setup y anule la selección de Usar proveedores de Terraform personalizados.

  3. Asigne un nombre a la pila y seleccione el compartimento de despliegue y, a continuación, haga clic en Siguiente.

  4. Deje los valores de arrendamiento sin modificar, introduzca su clave de API de Datadog y seleccione el punto final US5 (ocimetrics-intake.us5.datadoghq.com).

  5. Para la configuración de red, asegúrese de que la opción Crear VCN está activada y seleccione el compartimento adecuado para la creación de la VCN.

  6. En la sección Configuración de función, mantenga la unidad de aplicación por defecto como GENERIC_ARM. Introduzca el nombre de usuario y la contraseña del registro de Docker de OCI (contraseña satisfactoria).

  7. Defina el tamaño de lote de Service Connector Hub en 5000 y haga clic en Siguiente.

  8. Haga clic en Crear.

Tarea 3.3: Finalización de la configuración

  1. Vuelva al mosaico de integración de OCI de Datadog y haga clic en Crear configuración para completar la configuración.

  2. Este proceso garantiza que las métricas y funciones de Datadog estén configuradas correctamente para la integración con OCI.

    image

Tarea 4: Creación de OCI Functions

Para crear una aplicación en la consola de OCI, siga estos pasos:

  1. Vaya a Aplicaciones y seleccione Crear aplicación.

  2. Introduzca el nombre de la aplicación, seleccione la red virtual en la nube (VCN) y los detalles de subred adecuados, y haga clic en Crear.

  3. Para acceder a la aplicación recién creada, en Recursos, seleccione Introducción.

    image

  4. Haga clic en Iniciar Cloud Shell y copie los siguientes comandos de Uso del contexto para la región.

    fn list context
fn use context <region name>

  5. Actualice el contexto para incluir el ID de compartimento de la función.

    fn update context oracle.compartment-id <compartment-id>

  6. Actualice el contexto para incluir la ubicación del registro que desea utilizar.

    fn update context registry phx.ocir.io/<tenancy_name>/[YOUR-OCIR-REPO]

    Nota: Sustituya phx en contexto por el código de región de tres dígitos.

  7. Inicie sesión en el registro usando el token de autenticación como contraseña.

    docker login -u 'TENACNY_NAME/OCI_USERNAME' phx.ocir.io

  8. Se le solicitará la contraseña. Proporcione la contraseña adecuada.

    Nota:

    • Sustituya phx por el código de región de tres dígitos.
    • Si utiliza Oracle Identity Cloud Service, su nombre de usuario es <tenancyname>/oracleidentitycloudservice/<username>.

  9. Genere una función de texto fijo hola mundo.

    fn list apps
fn init --runtime python datadog

    El comando fn init generará una carpeta denominada datadog con tres archivos en el interior: func.py, func.yaml y requirements.txt.

  10. Ejecute el comando cd datadog.

  11. Abra func.py y sustituya el contenido del archivo por el siguiente fragmento de código.

    # oci-monitoring-metrics-to-datadog version 1.0.
#
# Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

import io
import json
import logging
import os
import re
import requests
from fdk import response
from datetime import datetime

"""
This sample OCI Function maps OCI Monitoring Service Metrics to the DataDog
REST API 'submit-metrics' contract found here:

https://docs.datadoghq.com/api/latest/metrics/#submit-metrics

"""

# Use OCI Application or Function configurations to override these environment variable defaults.

api_endpoint = os.getenv('DATADOG_METRICS_API_ENDPOINT', 'not-configured')
api_key = os.getenv('DATADOG_API_KEY', 'not-configured')
is_forwarding = eval(os.getenv('FORWARD_TO_DATADOG', "True"))
metric_tag_keys = os.getenv('METRICS_TAG_KEYS', 'name, namespace, displayName, resourceDisplayName, unit')
metric_tag_set = set()

# Set all registered loggers to the configured log_level

logging_level = os.getenv('LOGGING_LEVEL', 'INFO')
loggers = [logging.getLogger()] + [logging.getLogger(name) for name in logging.root.manager.loggerDict]
[logger.setLevel(logging.getLevelName(logging_level)) for logger in loggers]

# Exception stack trace logging

is_tracing = eval(os.getenv('ENABLE_TRACING', "False"))

# Constants

TEN_MINUTES_SEC = 10 * 60
ONE_HOUR_SEC = 60 * 60

# Functions

def handler(ctx, data: io.BytesIO = None):
    """
    OCI Function Entry Point
    :param ctx: InvokeContext
    :param data: data payload
    :return: plain text response indicating success or error
    """

    preamble = " {} / event count = {} / logging level = {} / forwarding to DataDog = {}"

    try:
        metrics_list = json.loads(data.getvalue())
        logging.getLogger().info(preamble.format(ctx.FnName(), len(metrics_list), logging_level, is_forwarding))
        logging.getLogger().debug(metrics_list)
        converted_event_list = handle_metric_events(event_list=metrics_list)
        send_to_datadog(event_list=converted_event_list)

    except (Exception, ValueError) as ex:
        logging.getLogger().error('error handling logging payload: {}'.format(str(ex)))
        if is_tracing:
            logging.getLogger().error(ex)


def handle_metric_events(event_list):
    """
    :param event_list: the list of metric formatted log records.
    :return: the list of DataDog formatted log records
    """

    result_list = []
    for event in event_list:
        single_result = transform_metric_to_datadog_format(log_record=event)
        result_list.append(single_result)
        logging.getLogger().debug(single_result)

    return result_list


def transform_metric_to_datadog_format(log_record: dict):
    """
    Transform metrics to DataDog format.
    See: https://github.com/metrics/spec/blob/v1.0/json-format.md
    :param log_record: metric log record
    :return: DataDog formatted log record
    """

    series = [{
        'metric': get_metric_name(log_record),
        'type' : get_metric_type(log_record),
        'points' : get_metric_points(log_record),
        'tags' : get_metric_tags(log_record),
    }]

    result = {
        'series' : series
    }
    return result


def get_metric_name(log_record: dict):
    """
    Assembles a metric name that appears to follow DataDog conventions.
    :param log_record:
    :return:
    """

    elements = get_dictionary_value(log_record, 'namespace').split('_')
    elements += camel_case_split(get_dictionary_value(log_record, 'name'))
    elements = [element.lower() for element in elements]
    return '.'.join(elements)


def camel_case_split(str):
    """
    :param str:
    :return: Splits camel case string to individual strings
    """

    return re.findall(r'[A-Z](?:[a-z]+|[A-Z]*(?=[A-Z]|$))', str)


def get_metric_type(log_record: dict):
    """
    :param log_record:
    :return: The type of metric. The available types are 0 (unspecified), 1 (count), 2 (rate), and 3 (gauge).
    Allowed enum values: 0,1,2,3
    """

    return 0


def get_now_timestamp():
    return datetime.now().timestamp()


def adjust_metric_timestamp(timestamp_ms):
    """
    DataDog Timestamps should be in POSIX time in seconds, and cannot be more than ten
    minutes in the future or more than one hour in the past.  OCI Timestamps are POSIX
    in milliseconds, therefore a conversion is required.

    See https://docs.datadoghq.com/api/latest/metrics/#submit-metrics
    :param oci_timestamp:
    :return:
    """

    # positive skew is expected
    timestamp_sec = int(timestamp_ms / 1000)
    delta_sec = get_now_timestamp() - timestamp_sec

    if (delta_sec > 0 and delta_sec > ONE_HOUR_SEC):
        logging.getLogger().warning('timestamp {} too far in the past per DataDog'.format(timestamp_ms))

    if (delta_sec < 0 and abs(delta_sec) > TEN_MINUTES_SEC):
        logging.getLogger().warning('timestamp {} too far in the future per DataDog'.format(timestamp_ms))

    return timestamp_sec


def get_metric_points(log_record: dict):
    """
    :param log_record:
    :return: an array of arrays where each array is a datapoint scalar pair
    """

    result = []

    datapoints = get_dictionary_value(dictionary=log_record, target_key='datapoints')
    for point in datapoints:
        dd_point = {'timestamp': adjust_metric_timestamp(point.get('timestamp')),
                    'value': point.get('value')}

        result.append(dd_point)

    return result


def get_metric_tags(log_record: dict):
    """
    Assembles tags from selected metric attributes.
    See https://docs.datadoghq.com/getting_started/tagging/
    :param log_record: the log record to scan
    :return: string of comma-separated, key:value pairs matching DataDog tag format
    """

    result = []

    for tag in get_metric_tag_set():
        value = get_dictionary_value(dictionary=log_record, target_key=tag)
        if value is None:
            continue

        if isinstance(value, str) and ':' in value:
            logging.getLogger().warning('tag contains a \':\' / ignoring {} ({})'.format(key, value))
            continue

        tag = '{}:{}'.format(tag, value)
        result.append(tag)

    return result


def get_metric_tag_set():
    """
    :return: the set metric payload keys that we would like to have converted to tags.
    """

    global metric_tag_set

    if len(metric_tag_set) == 0 and metric_tag_keys:
        split_and_stripped_tags = [x.strip() for x in metric_tag_keys.split(',')]
        metric_tag_set.update(split_and_stripped_tags)
        logging.getLogger().debug("tag key set / {} ".format (metric_tag_set))

    return metric_tag_set


def send_to_datadog (event_list):
    """
    Sends each transformed event to DataDog Endpoint.
    :param event_list: list of events in DataDog format
    :return: None
    """

    if is_forwarding is False:
        logging.getLogger().debug("DataDog forwarding is disabled - nothing sent")
        return

    if 'v2' not in api_endpoint:
        raise RuntimeError('Requires API endpoint version "v2": "{}"'.format(api_endpoint))

    # creating a session and adapter to avoid recreating
    # a new connection pool between each POST call

    try:
        session = requests.Session()
        adapter = requests.adapters.HTTPAdapter(pool_connections=10, pool_maxsize=10)
        session.mount('https://', adapter)

        for event in event_list:
            api_headers = {'Content-type': 'application/json', 'DD-API-KEY': api_key}
            logging.getLogger().debug("json to datadog: {}".format (json.dumps(event)))
            response = session.post(api_endpoint, data=json.dumps(event), headers=api_headers)

            if response.status_code != 202:
                raise Exception ('error {} sending to DataDog: {}'.format(response.status_code, response.reason))

    finally:
        session.close()


def get_dictionary_value(dictionary: dict, target_key: str):
    """
    Recursive method to find value within a dictionary which may also have nested lists / dictionaries.
    :param dictionary: the dictionary to scan
    :param target_key: the key we are looking for
    :return: If a target_key exists multiple times in the dictionary, the first one found will be returned.
    """

    if dictionary is None:
        raise Exception('dictionary None for key'.format(target_key))

    target_value = dictionary.get(target_key)
    if target_value:
        return target_value

    for key, value in dictionary.items():
        if isinstance(value, dict):
            target_value = get_dictionary_value(dictionary=value, target_key=target_key)
            if target_value:
                return target_value

        elif isinstance(value, list):
            for entry in value:
                if isinstance(entry, dict):
                    target_value = get_dictionary_value(dictionary=entry, target_key=target_key)
                    if target_value:
                        return target_value


def local_test_mode(filename):
    """
    This routine reads a local json metrics file, converting the contents to DataDog format.
    :param filename: cloud events json file exported from OCI Logging UI or CLI.
    :return: None
    """

    logging.getLogger().info("local testing started")

    with open(filename, 'r') as f:
        transformed_results = list()

        for line in f:
            event = json.loads(line)
            logging.getLogger().debug(json.dumps(event, indent=4))
            transformed_result = transform_metric_to_datadog_format(event)
            transformed_results.append(transformed_result)

        logging.getLogger().debug(json.dumps(transformed_results, indent=4))
        send_to_datadog(event_list=transformed_results)

    logging.getLogger().info("local testing completed")


"""
Local Debugging
"""

if __name__ == "__main__":
    local_test_mode('oci-metrics-test-file.json')

  12. Actualice func.yaml con el siguiente código. Sustituya DATADOG_TOKEN por su clave de API de Datadog y DATADOG_HOST por el punto final de REST - https://http-intake.logs.datadoghq.com/v1/input . Para obtener más información sobre el punto final de REST, consulte Recopilación e integraciones de logs.

    schema_version: 20180708
name: datadogapp
version: 0.0.1
runtime: python
entrypoint: /python/bin/fdk /function/func.py handler
memory: 1024
timeout: 120
config:
DATADOG_HOST: https://http-intake.logs.datadoghq.com/v1/input
DATADOG_TOKEN: ZZZZZzzzzzzzzzz

  13. Actualice requirements.txt con el siguiente código.

    fdk
dattime
requests
oci

  14. Ejecute el siguiente comando para crear la aplicación y desplegar las funciones para completar la configuración.

    fn create app datadog01 --annotation oracle.com/oci/subnetIds='["Provide your subnet OCID"]'

  15. Ejecute el siguiente comando para desplegar las funciones para completar la configuración.

    fn -v deploy --app datadog

Tarea 5: Configuración de OCI Connector Hub

  1. Vaya a la consola de OCI, vaya a Logging, Connectors y haga clic en Create Connector.

  2. Defina el Origen en Supervisión y el Destino en Funciones.

  3. En Configurar conexión de origen, seleccione el compartimento de métrica y el espacio de nombre adecuados. Por ejemplo, oci_postgresql para la supervisión de la base de datos.

  4. En Configurar destino, seleccione el compartimento, la aplicación de función y la función creados en la tarea 4.

  5. Si se le solicita, haga clic en Crear para crear la política necesaria.

  6. Haga clic en Crear para finalizar la configuración de OCI Connector Hub.

image

Tarea 6: Visualización de métricas en Datadog

OCI Connector Hub ahora está configurado para disparar la función, lo que permite la ingesta de métricas en Datadog cada vez que se detectan nuevas métricas. En el mosaico Integración de Datadog, vaya a Métricas y revise el resumen para ver las métricas relacionadas con OCI.

image

En el mosaico Integración de Datadog, haga clic en Explorador para analizar y seleccionar las métricas de OCI necesarias según sea necesario.

image

Solución de problemas

Si no aparece ningún dato en la página Resumen de métricas, seleccione Activar log para activar el registro para que las funciones revisen los logs y depuren la incidencia.

image

Agradecimientos

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de formación gratuita en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.