Elastic Compute Service:Protect Alibaba Cloud accounts and prevent credential leakage

Protéger les mots de passe du compte et activer l'authentification MFA

• Définissez des mots de passe complexes : les mots de passe faibles constituent une cause principale de compromission de compte. Évitez les mots de passe simples pour prévenir les attaques par force brute.

• Changez régulièrement vos mots de passe : modifiez votre mot de passe tous les 90 jours afin de réduire le risque de fuite lié à une utilisation prolongée.

• Activez l'authentification MFA : Associer ou dissocier un dispositif MFA virtuel pour votre compte Alibaba Cloud et vos utilisateurs RAM. L'authentification MFA ajoute un code de vérification dynamique, tel qu'un jeton mobile ou une clé protégée matériellement, comme couche supplémentaire au-delà de l'authentification par mot de passe, afin d'empêcher tout accès non autorisé.

Utiliser des rôles RAM ECS plutôt que des AccessKeys

Si une application exécutée sur une instance ECS doit appeler des API Alibaba Cloud, par exemple pour le scaling ECS, utilisez un rôle RAM plutôt qu'une AccessKey.

from alibabacloud_credentials.client import Client as CredClient
from alibabacloud_credentials.models import Config as CredConfig
from alibabacloud_tea_openapi.models import Config
from alibabacloud_ecs20140526.client import Client as EcsClient
from alibabacloud_ecs20140526 import models as ecs_models
from alibabacloud_tea_util.models import RuntimeOptions

# Step 1: Obtain an STS token
def get_sts_token():
    config = CredConfig(
        type="ecs_ram_role",
        enable_imds_v1=False
    )
    cred_client = CredClient(config)
    credential = cred_client.get_credential()
    return {
        "AccessKeyId": credential.get_access_key_id(),
        "AccessKeySecret": credential.get_access_key_secret(),
        "SecurityToken": credential.get_security_token()
    }

# Step 2: Initialize the ECS client
def create_ecs_client(sts_token):
    config = Config(
        access_key_id=sts_token["AccessKeyId"],
        access_key_secret=sts_token["AccessKeySecret"],
        security_token=sts_token["SecurityToken"],
        endpoint="ecs.cn-hangzhou.aliyuncs.com"
    )
    return EcsClient(config)

# Step 3: Build the request to create an instance
def build_create_instance_request():
    return ecs_models.RunInstancesRequest(
        region_id="cn-hangzhou",
        image_id="aliyun_3_x64_20G_scc_alibase_20220225.vhd",
        instance_type="ecs.e-c1m2.xlarge",
        security_group_id="sg-bp1esyhwfbqeyudt****",
        v_switch_id="vsw-bp1nzprm8h7mmnl8t****",
        instance_name="sdk-test",
        instance_charge_type="PostPaid",
        key_pair_name="sdk-key-pair",
        system_disk_category="cloud_essd"
    )

# Step 4: Call the API to create the instance
def create_instance(client, request):
    runtime = RuntimeOptions()
    try:
        response = client.run_instances_with_options(request, runtime)
        print("Instance created successfully. Instance ID:", response.body.instance_id_sets.instance_id_set[0])
    except Exception as e:
        print("Failed to create instance. Error message:", e)

# Main function
if __name__ == "__main__":
    sts_token = get_sts_token()  # Obtain an STS token
    ecs_client = create_ecs_client(sts_token)  # Initialize the ECS client
    request = build_create_instance_request()  # Build the request to create an instance
    create_instance(ecs_client, request)  # Call the API to create the instance

Protéger les AccessKeys et réduire le risque de fuite

Si vous devez utiliser une AccessKey, renforcez sa gestion de sécurité tout au long de son cycle de vie — création, stockage, distribution et utilisation.

• Création : appliquez le principe « une AccessKey par personne, une AccessKey par application ». Ne partagez pas une AccessKey entre plusieurs utilisateurs ou programmes. Cela vous permet d'identifier rapidement la partie responsable, de limiter l'impact et de faire tourner la clé en cas de fuite.

• Gestion des autorisations : suivez le principe du moindre privilège et n'accordez que les autorisations nécessaires. Utilisez des utilisateurs RAM et attribuez les autorisations en fonction des responsabilités. Évitez d'utiliser l'AccessKey du compte Alibaba Cloud. Consultez Éviter d'utiliser votre compte Alibaba Cloud et accorder différentes autorisations aux utilisateurs RAM selon leurs responsabilités.

• Stockage sécurisé : stockez les AccessKeys sur des appareils de confiance, tels que :

  • Un fichier lisible uniquement par root ou un utilisateur spécifique.

  • Une base de données ou Key Management Service (KMS) avec contrôle d'accès.

  • Ne stockez pas les AccessKeys dans des notes, des référentiels de code, des historiques de chat ou des signatures personnelles.

• Distribution sécurisée : envoyez le fichier AccessKey chiffré via un canal (par exemple, l'e-mail) et le mot de passe de déchiffrement via un canal séparé (par exemple, un SMS).

• Utilisation sécurisée : n'intégrez pas les AccessKeys en dur dans votre code. Stockez l'AccessKey dans un fichier de configuration séparé, chiffrez-le et enregistrez-le sur un serveur de confiance. Après la distribution, déchiffrez le fichier et définissez les autorisations de sorte que seul le propriétaire puisse le lire.

• Contrôle d'accès réseau : configurez une politique de contrôle d'accès réseau pour l'AccessKey dans la console RAM.

• Rotation et nettoyage réguliers

  • Effectuer une rotation régulière : Faire tourner votre AccessKey tous les 90 jours. Générez une nouvelle AccessKey et informez les utilisateurs de la mise à jour.

  • Nettoyer régulièrement : vérifiez les enregistrements d'opération des AccessKeys dans la console RAM et révoquez les clés inutilisées. Consultez Supprimer l'AccessKey d'un utilisateur RAM.

• Surveiller les fuites d'AccessKey : utilisez la fonctionnalité Détection de fuite d'AccessKey dans Security Center pour vérifier si une AccessKey a été divulguée. Cette fonctionnalité prend en charge les notifications d'alerte. En cas de fuite, Alibaba Cloud fournit une protection restrictive pour l'AccessKey afin d'éviter toute escalade.

Conformité