Create custom rule Function Compute Cloud Config - Cloud Config

Utilisez une fonction Function Compute pour créer une règle de conformité personnalisée dans Cloud Config. Cette rubrique prend pour exemple la vérification du nombre de cœurs CPU d'une instance ECS.

Prérequis

Le service Function Compute est activé. Pour plus d'informations, consultez la page Activation de Function Compute.

Remarque

L'utilisation de Function Compute engendre des frais. Pour en savoir plus, reportez-vous à la section Présentation de la facturation.

Contexte

Pour comprendre les concepts, les cas d'utilisation et le fonctionnement des règles basées sur des fonctions personnalisées, consultez la page Définition et principes de fonctionnement des règles basées sur des fonctions personnalisées.

Procédure

Dans cet exemple, une fonction vérifie le nombre de cœurs CPU des instances ECS. Les instances disposant de deux cœurs CPU ou moins sont signalées comme non conformes.

Créez un service.
1. Connectez-vous à la console Function Compute.
2. Dans le volet de navigation de gauche, cliquez sur Services & Functions.
3. Dans la barre de navigation supérieure, sélectionnez une région, par exemple ou Singapore (Singapore).
4. Sur la page Services, cliquez sur Create Service.
5. Dans le panneau Create Service, saisissez un Name pour le service et conservez les valeurs par défaut pour les autres paramètres.
6. Cliquez sur OK.
Créez une fonction.
1. Dans le service que vous avez créé à l'étape Étape 1, cliquez sur Create Function.
2. Sur la page Create Function, saisissez un Function Name. Définissez le paramètre Request Handler Type sur Event Handler et le paramètre Runtime sur Python 3.10. Conservez les valeurs par défaut pour les autres paramètres.
3. Cliquez sur Create.

Configurez le code de la fonction.

Copiez le code suivant et collez-le dans le fichier index.py.

# #!/usr/bin/env python
# # -*- encoding: utf-8 -*-
import json
import logging

from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest

logger = logging.getLogger()
# Compliance types.
COMPLIANCE_TYPE_COMPLIANT = 'COMPLIANT'
COMPLIANCE_TYPE_NON_COMPLIANT = 'NON_COMPLIANT'
COMPLIANCE_TYPE_NOT_APPLICABLE = 'NOT_APPLICABLE'
# Resource configuration delivery types.
CONFIGURATION_TYPE_COMMON = 'COMMON'
CONFIGURATION_TYPE_OVERSIZE = 'OVERSIZE'
CONFIGURATION_TYPE_NONE = 'NONE'

# The entry point function that orchestrates and processes business logic.
def handler(event, context):
    """
    The handler function.
    :param event: The event data.
    :param context: The context object.
    :return: The evaluation results.
    """
    # The input parameters of the function.
    logger.info(f'Printing function input parameters:{event}')

    # Validate the event. You can copy this code block directly.
    evt = validate_event(event)
    if not evt:
        return None
    creds = context.credentials
    rule_parameters = evt.get('ruleParameters')
    result_token = evt.get('resultToken')
    invoking_event = evt.get('invokingEvent')
    ordering_timestamp = evt.get('orderingTimestamp')

    # The resource configuration. This parameter has a value when the trigger is set to Configuration Change.
    # When you create or manually run a rule, Cloud Config invokes the function to evaluate all specified resources one by one.
    # If the configuration of a resource changes, Cloud Config automatically invokes the function to evaluate the resource based on the change.
    configuration_item = invoking_event.get('configurationItem')
    account_id = configuration_item.get('accountId')
    resource_id = configuration_item.get('resourceId')
    resource_type = configuration_item.get('resourceType')
    region_id = configuration_item.get('regionId')
    resource_name = configuration_item.get('resourceName')

    # Check whether the size of the delivered resource configuration exceeds the upper limit (100 KB).
    # If it does, you must call the API for querying resource details to obtain the complete data.
    configuration_type = invoking_event.get('configurationType')
    if configuration_type and configuration_type == CONFIGURATION_TYPE_OVERSIZE:
        resource_result = get_discovered_resource(creds, resource_id, resource_type, region_id)
        resource_json = json.loads(resource_result)
        configuration_item["configuration"] = resource_json["DiscoveredResourceDetail"]["Configuration"]

    # Evaluate the resource. You must implement the evaluation logic based on your business requirements. The following code is for reference only.
    compliance_type, annotation = evaluate_configuration_item(
        rule_parameters, configuration_item)

    # Set the evaluation results. The format must comply with the following example.
    evaluations = [
        {
            'accountId': account_id,
            'complianceResourceId': resource_id,
            'complianceResourceName': resource_name,
            'complianceResourceType': resource_type,
            'complianceRegionId': region_id,
            'orderingTimestamp': ordering_timestamp,
            'complianceType': compliance_type,
            'annotation': annotation
        }
    ]

    # Submit the evaluation results to Cloud Config. You can copy this code block directly.
    put_evaluations(creds, result_token, evaluations)
    return evaluations

# Evaluate the number of CPU cores in the ECS instance.
def evaluate_configuration_item(rule_parameters, configuration_item):
    """
    The evaluation logic.
    :param rule_parameters: The parameters of the rule.
    :param configuration_item: The configuration item.
    :return: The compliance evaluation result.
    """
    # Initialize the return values.
    compliance_type = COMPLIANCE_TYPE_COMPLIANT
    annotation = None

    # Obtain the complete configuration of the resource.
    full_configuration = configuration_item['configuration']
    if not full_configuration:
        annotation = 'Configuration is empty.'
        return compliance_type, annotation

    # Convert the configuration to the JSON format.
    configuration = parse_json(full_configuration)
    cpu_count = configuration.get('Cpu')
    eq_count = rule_parameters.get('CpuCount')
    if cpu_count and cpu_count <= int(eq_count):
      annotation = json.dumps({"configuration":cpu_count,"desiredValue":eq_count,"operator":"Greater","property":"$.Cpu"})
      compliance_type = COMPLIANCE_TYPE_NON_COMPLIANT
      return compliance_type, annotation
    return compliance_type, annotation

def validate_event(event):
    """
    Validate the event.
    :param event: The event data.
    :return: The JSON object.
    """
    if not event:
        logger.error('Event is empty.')
    evt = parse_json(event)
    logger.info('Loading event: %s .' % json.dumps(evt))

    if 'resultToken' not in evt:
        logger.error('ResultToken is empty.')
        return None
    if 'ruleParameters' not in evt:
        logger.error('RuleParameters is empty.')
        return None
    if 'invokingEvent' not in evt:
        logger.error('InvokingEvent is empty.')
        return None
    return evt

def parse_json(content):
    """
    Parse a JSON string.
    :param content: The JSON string.
    :return: The JSON object.
    """
    try:
        return json.loads(content)
    except Exception as e:
        logger.error('Parse content:{} to json error:{}.'.format(content, e))
        return None

# Submit the evaluation results to Cloud Config. You can copy this code block directly.
def put_evaluations(creds, result_token, evaluations):
    """
    Submits the evaluation results to Cloud Config.
    :param context: The context of Function Compute.
    :param result_token: The callback token.
    :param evaluations: The evaluation results.
    :return: None
    """
    # The Function Compute service role must have the AliyunConfigFullAccess permission.
    client = AcsClient(creds.access_key_id, creds.access_key_secret, region_id='cn-shanghai')

    # Create a request and set its parameters. The domain is config.cn-shanghai.aliyuncs.com.
    request = CommonRequest()
    request.set_domain('config.cn-shanghai.aliyuncs.com')
    request.set_version('2020-09-07')
    request.set_action_name('PutEvaluations')
    request.add_body_params('ResultToken', result_token)
    request.add_body_params('Evaluations', evaluations)
    request.add_body_params('SecurityToken', creds.security_token)
    request.set_method('POST')

    try:
        response = client.do_action_with_exception(request)
        logger.info('PutEvaluations with request: {}, response: {}.'.format(request, response))
    except Exception as e:
        logger.error('PutEvaluations error: %s' % e)

Remarque

Ce code vérifie le nombre de cœurs CPU. Pour identifier le nom du paramètre correspondant à votre propre règle, inspectez la configuration de la ressource (configuration). Pour plus d'informations, consultez les pages Affichage des informations sur les ressources et Étape 6. Par exemple, dans la section Configuration Details d'une instance ECS, cliquez sur View JSON. Le paramètre correspondant au nombre de cœurs CPU est Cpu. Récupérez la valeur attendue CpuCount depuis rule_parameters.

La fonction soumet les résultats d'évaluation en appelant l'opération d'API PutEvaluations. Notez le champ DeleteMode. S'il est activé, les résultats d'évaluation qui ne sont pas mis à jour lors de l'évaluation actuelle sont automatiquement supprimés.

Dans le coin supérieur gauche, cliquez sur Deploy Code.

Créez une règle personnalisée en utilisant Function Compute.
1. Connectez-vous à la console Cloud Config.
2. Facultatif. Dans le coin supérieur gauche, sélectionnez un groupe de comptes.
  
  Cette opération n'est requise que si vous utilisez un compte de gestion d'un répertoire de ressources. Dans le cas contraire, vous n'avez pas besoin de l'effectuer.
3. Dans le volet de navigation de gauche, choisissez Compliance & Audit > Rules.
4. Sur la page Rules, cliquez sur Create Rule.
5. Sur la page Select Create Method, sélectionnez Based on Function Compute, puis sélectionnez Function ARN et cliquez sur Next.
  
  Pour le paramètre Function ARN, définissez la Region sur ou Singapore (Singapore). Pour le paramètre Service, sélectionnez le service que vous avez créé à l'étape Étape 1. Pour le paramètre Function, sélectionnez la fonction que vous avez créée à l'étape Étape 2.
6. Sur la page Set Basic Properties, saisissez un Rule Name et cliquez sur Add Rule Parameter. Saisissez CpuCount pour le paramètre Rule Parameters et 2 pour le paramètre Expected Value. Ensuite, définissez le paramètre Trigger sur Configuration Changes et cliquez sur Next.
  Remarque
  - Le nom du paramètre de règle doit correspondre à la clé rule_parameters présente dans le code de l'étape Étape 3.
  - Lorsque vous créez, modifiez ou réévaluez une règle, Cloud Config envoie les configurations de toutes les ressources du type spécifié à Function Compute pour évaluation.
7. Sur la page Set Effective Scope, définissez le paramètre Resource Type sur ECS Instance et cliquez sur Next.
  Remarque
  - Pour éviter les évaluations invalides, sélectionnez uniquement les types de ressources que vous souhaitez évaluer.
  - La règle évalue toutes les ressources du type associé présentes dans votre compte.
8. Sur la page Set Correction, cliquez sur Submit.
  
  Remarque
  Vous pouvez activer l'option Set Correction et configurer une correction personnalisée. Consultez la page Configuration d'une correction personnalisée.
Consultez les résultats de détection.

La liste Rules affiche le nombre de ressources non conformes détectées par la règle.

Remarque
Cliquez sur un Rule Identifier ou sur Details dans la colonne Actions pour afficher les Compliance Result of Related Resources.

Si la colonne Non-compliant Resources de la règle affiche No Data alors que des ressources correspondantes existent dans votre compte, il se peut que l'appel de fonction ou la soumission de l'évaluation ait échoué. Dans l'onglet Invocation Log de la fonction, cliquez sur Request Log dans la colonne Actions pour résoudre le problème. Pour plus d'informations, consultez la section Affichage des journaux d'appel.

Cloud Config:Créer une règle personnalisée avec Function Compute

Prérequis

Contexte

Procédure

Rubriques connexes