Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Creazione di un ambiente di test
Questa guida fornisce test pratici per convalidare la funzionalità di risposta agli incidenti di AWS DevOps Agent utilizzando un'architettura di esempio. Utilizzate questo supplemento se desiderate testare DevOps Agent prima di collegare i sistemi di produzione.
## Prerequisiti
+ AWS account con accesso amministrativo
+ AWS DevOps Agent Space creato e configurato utilizzando il flusso di ruoli Auto create DevOps Agent
## Panoramica dei costi e della sicurezza
### Protezione dei costi
+ **Test EC2**: GRATUITO (livello AWS gratuito) o \$1\$10,02 per 2 ore
+ **Test Lambda**: GRATUITO (livello gratuito di 1 milione requests/month )
+ **CloudWatch**: GRATUITO (10 allarmi, metriche di base incluse)
+ **Costo totale stimato previsto**: 0,00 USD - 0,05 USD per il test completo
### Caratteristiche di sicurezza in questi test
+ **Terminazione automatica**: spegnimento automatico integrato
+ **Idoneo al piano gratuito**: utilizza i tipi di istanze più piccoli
+ **Ambito limitato**: risorse di test minime e isolate
+ **Pulizia semplice**: semplici passaggi da console per rimuovere tutto
+ **Nessun impatto sulla produzione**: ambiente di test completamente separato
## Configura il tuo AWS account per i test
**Importante**
**Le risorse dell'infrastruttura devono essere distribuite nell' AWS account in cui hai creato l'account cloud principale di DevOps Agent Space. La regione specifica non ha importanza.
1. Accedi alla AWS console: [https://console.aws.amazon.com](https://console.aws.amazon.com/)
1. Assicurati di lavorare con lo stesso AWS account in cui si trova il tuo DevOps Agent Space
1. Puoi utilizzare qualsiasi regione per le tue risorse di test
**Nota**
La mappatura 1:1 tra l'account principale del vostro DevOps agente e le risorse dell'ambiente di test che state creando semplifica la configurazione del test. Puoi facilmente estendere il tuo DevOps Agent Space per includere account secondari e abilitare indagini su più account.
## Scegli il tuo test
Puoi eseguire entrambi i test indipendentemente o entrambi insieme:
### Opzione di test A: test della capacità della CPU EC2
**Scopo**: convalidare la capacità dell' AWS DevOps agente di rilevare e analizzare i problemi di prestazioni di EC2
**Tempo stimato**: 5 minuti di configurazione\$110 minuti di esecuzione automatica
**Difficoltà**: Completamente automatizzato (non sono richiesti passaggi manuali)
### Opzione di test B: test del tasso di errore Lambda
**Scopo**: convalidare la capacità dell' AWS DevOps agente di rilevare e analizzare gli errori della funzione Lambda
**Tempo stimato**: 10 minuti di configurazione\$1 2 minuti di attivazione
**Difficoltà**: Molto facile
## Opzione di test A: test della capacità della CPU EC2
### Fase 1: Implementazione CloudFormation dello stack per il test EC2
Le utilizzeremo CloudFormation per creare le nostre risorse di test, che consentiranno ad AWS DevOps Agent di monitorarle e analizzarle correttamente.
1. **Vai a CloudFormation**:
1. In AWS Console, cerca "CloudFormation" e fai clic su **CloudFormation**
1. Fai clic su **Crea pila** > **Con nuove risorse (standard)**
1. **Carica modello**:
1. Crea un nuovo file locale chiamato `AWS-DevOpsAgent-ec2-test.yaml`
1. Copia e incolla questo CloudFormation modello nel file:
1.
```
AWSTemplateFormatVersion: '2010-09-09'
Description: 'AWS DevOps Agent EC2 CPU Test Stack'
Parameters:
MyIP:
Type: String
Description: Your current IP address for SSH access (find at https://whatismyipaddress.com)
Default: '0.0.0.0/0'
Resources:
# Security Group for SSH access
TestSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupName: AWS-DevOpsAgent-test-sg
GroupDescription: AWS DevOps Agent beta testing security group
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 22
ToPort: 22
CidrIp: !Ref MyIP
Description: SSH access from your IP
Tags:
- Key: Name
Value: AWS-DevOpsAgent-Test-SG
- Key: Purpose
Value: AWS-DevOpsAgent-Testing
# Key Pair for SSH access
TestKeyPair:
Type: AWS::EC2::KeyPair
Properties:
KeyName: AWS-DevOpsAgent-test-key
KeyType: rsa
Tags:
- Key: Name
Value: AWS-DevOpsAgent-Test-Key
- Key: Purpose
Value: AWS-DevOpsAgent-Testing
# EC2 Instance for CPU testing
TestInstance:
Type: AWS::EC2::Instance
Properties:
InstanceType: t3.micro
ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}'
KeyName: !Ref TestKeyPair
SecurityGroupIds:
- !Ref TestSecurityGroup
UserData:
Fn::Base64: !Sub |
#!/bin/bash
yum update -y
yum install -y htop
# Create the CPU stress test script
cat > /home/ec2-user/cpu-stress-test.sh << 'EOF'
#!/bin/bash
echo "Starting AWS DevOpsAgent CPU Stress Test"
echo "Time: $(date)"
echo "Instance: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)"
echo ""
# Get number of CPU cores
CORES=$(nproc)
echo "CPU Cores: $CORES"
echo ""
echo "Starting stress test (5 minutes)..."
echo "This will generate >70% CPU usage to trigger CloudWatch alarm"
echo ""
# Create CPU load using yes command
echo "Starting CPU load processes..."
for i in $(seq 1 $CORES); do
(yes > /dev/null) &
CPU_PID=$!
echo "Started CPU load process $i (PID: $CPU_PID)"
echo $CPU_PID >> /tmp/cpu_test_pids
done
# Auto-cleanup after 5 minutes
(sleep 300 && echo "Stopping CPU load processes..." && kill $(cat /tmp/cpu_test_pids 2>/dev/null) 2>/dev/null && rm -f /tmp/cpu_test_pids) &
echo ""
echo "CPU load processes started for 5 minutes"
echo "Check CloudWatch for alarm trigger in 3-5 minutes"
EOF
chmod +x /home/ec2-user/cpu-stress-test.sh
chown ec2-user:ec2-user /home/ec2-user/cpu-stress-test.sh
# Create auto-shutdown script (safety mechanism)
cat > /home/ec2-user/auto-shutdown.sh << 'SHUTDOWN_EOF'
#!/bin/bash
echo "Auto-shutdown scheduled for 2 hours from now: $(date)"
sleep 7200
echo "Auto-shutdown executing at: $(date)"
sudo shutdown -h now
SHUTDOWN_EOF
chmod +x /home/ec2-user/auto-shutdown.sh
nohup /home/ec2-user/auto-shutdown.sh > /home/ec2-user/auto-shutdown.log 2>&1 &
echo "AWS DevOpsAgent test setup completed at $(date)" > /home/ec2-user/setup-complete.txt
Tags:
- Key: Name
Value: AWS-DevOpsAgent-Test-Instance
- Key: Purpose
Value: AWS-DevOpsAgent-Testing
# CloudWatch Alarm for CPU utilization
CPUAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: AWS-DevOpsAgent-EC2-CPU-Test
AlarmDescription: AWS-DevOpsAgent beta test - EC2 CPU utilization alarm
MetricName: CPUUtilization
Namespace: AWS/EC2
Statistic: Average
Period: 60
EvaluationPeriods: 1
Threshold: 70
ComparisonOperator: GreaterThanThreshold
Dimensions:
- Name: InstanceId
Value: !Ref TestInstance
TreatMissingData: notBreaching
Outputs:
InstanceId:
Description: EC2 Instance ID for testing
Value: !Ref TestInstance
SecurityGroupId:
Description: Security Group ID
Value: !Ref TestSecurityGroup
AlarmName:
Description: CloudWatch Alarm Name
Value: !Ref CPUAlarm
SSHCommand:
Description: SSH command to connect to instance
Value: !Sub 'ssh -i "AWS-DevOpsAgent-test-key.pem" ec2-user@${TestInstance.PublicDnsName}'
```
1. Nella CloudFormation console, seleziona **Carica un file modello**
1. Fai clic su **Scegli file**
1. Seleziona il `AWS-DevOpsAgent-ec2-test.yaml` file
1. Fai clic su **Avanti**
1. **Configura lo stack**:
1. **Nome dello stack**: `AWS-DevOpsAgent-EC2-Test`
1. **Parametri:**
1. **MyIP**: lascia come impostazione predefinita `0.0.0.0/0` (puoi proteggerlo in seguito, se necessario)
1. **Fai clic su Avanti**
1. **Configura le opzioni dello stack:**
1. **Lascia le impostazioni predefinite, fai clic su Avanti**
1. **Revisione e creazione**:
1. Seleziona **Riconosco che AWS CloudFormation potrebbe creare risorse** IAM
1. Fai clic su **Invia**
1. **Attendi il completamento**:
1. La creazione dello stack richiede 3-5 minuti
1. Lo stato cambierà da a `CREATE_IN_PROGRESS` `CREATE_COMPLETE`
1. **Importante**: la tua istanza EC2 fa ora parte di uno CloudFormation stack in AWS DevOpsAgent grado di tracciare\$1
#### Opzionale: accesso SSH sicuro (solo se prevedi di connetterti all'istanza)
Salta questo passaggio se desideri solo eseguire il test automatico
1. **Vai ai gruppi di sicurezza EC2**:
1. **In AWS Console, vai a **EC2** → Gruppi di sicurezza**
1. Trova `AWS-DevOpsAgent-test-sg`
1. **Aggiorna la regola SSH**:
1. Seleziona il gruppo di sicurezza → scheda **Regole in entrata → **Modifica** regole** in entrata
1. Trova la regola SSH (porta 22)
1. Cambia la fonte dal `0.0.0.0/0` tuo IP: `[YOUR_IP]/32`
1. Ottieni il tuo IP da [https://whatismyipaddress.com](https://whatismyipaddress.com/)
1. Fai clic su **Salva regole**
### Fase 2: Attendi l'esecuzione automatica del test
1. **Esecuzione automatica del test**:
+ Lo stress test della CPU verrà **avviato automaticamente 5 minuti** dopo l'avvio dell'istanza
+ Non è richiesto alcun intervento manuale: basta attendere, il test viene eseguito completamente in background
1. **Monitora il test**:
+ L'istanza si avvia e prepara il test automaticamente
+ Lo script verrà eseguito per 5 minuti e genererà un utilizzo della CPU superiore al 70%
+ CloudWatch l'allarme dovrebbe attivarsi entro 8-10 minuti in totale (5 minuti di ritardo\$1 3-5 minuti di allarme)
1. **Opzionale: riesecuzione manuale** (per test aggiuntivi):
+ Connettiti alla tua istanza: console EC2 → → **Connect `AWS-DevOpsAgent-Test-Instance`** → **Session Manager**
+ Esegui nuovamente lo stress test: `./cpu-stress-test.sh`
+ Perfetto per AWS DevOpsAgent la risposta dei test più volte
## Opzione di test B: test del tasso di errore Lambda
### Fase 1: Implementazione CloudFormation dello stack per il test Lambda
1. **Passa a: CloudFormation**
1. In AWS Console, vai a **CloudFormation**
1. Fai clic su **Crea pila** → **Con nuove risorse (standard)**
1. **Carica modello**:
1. Crea un nuovo file locale chiamato `AWS-DevOpsAgent-lambda-test.yaml`
1. Copia e incolla questo CloudFormation modello nel file:
1.
```
AWSTemplateFormatVersion: '2010-09-09'
Description: 'AWS DevOpsAgent Lambda Error Test Stack'
Resources:
# IAM Role for Lambda function
LambdaExecutionRole:
Type: AWS::IAM::Role
Properties:
RoleName: AWS-DevOpsAgentLambdaTestRole
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Tags:
- Key: Name
Value: AWS-DevOpsAgent-Lambda-Test-Role
- Key: Purpose
Value: AWS-DevOpsAgent-Testing
# Lambda function that generates errors
TestLambdaFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: AWS-DevOpsAgent-test-lambda
Runtime: python3.12
Handler: index.lambda_handler
Role: !GetAtt LambdaExecutionRole.Arn
Code:
ZipFile: |
import json
import random
import time
from datetime import datetime
def lambda_handler(event, context):
print(f"AWS DevOpsAgent Test Lambda - {datetime.now()}")
print(f"Event: {json.dumps(event)}")
# Intentionally generate errors for testing
error_scenarios = [
"Simulated database connection timeout",
"Test API rate limit exceeded",
"Intentional validation error for AWS DevOpsAgent testing"
]
# Always throw an error for testing purposes
error_message = random.choice(error_scenarios)
print(f"Generating test error: {error_message}")
# This will create a Lambda error that CloudWatch will detect
raise Exception(f"AWS DevOpsAgent Test Error: {error_message}")
Description: AWS DevOpsAgent beta test function - intentionally generates errors
Timeout: 30
Tags:
- Key: Name
Value: AWS-DevOpsAgent-Test-Lambda
- Key: Purpose
Value: AWS-DevOpsAgent-Testing
# CloudWatch Alarm for Lambda errors
LambdaErrorAlarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmName: AWS-DevOpsAgent-Lambda-Error-Test
AlarmDescription: AWS-DevOpsAgent beta test - Lambda error rate alarm
MetricName: Errors
Namespace: AWS/Lambda
Statistic: Sum
Period: 60
EvaluationPeriods: 1
Threshold: 0
ComparisonOperator: GreaterThanThreshold
Dimensions:
- Name: FunctionName
Value: !Ref TestLambdaFunction
TreatMissingData: notBreaching
Outputs:
LambdaFunctionName:
Description: Lambda Function Name for testing
Value: !Ref TestLambdaFunction
LambdaFunctionArn:
Description: Lambda Function ARN
Value: !GetAtt TestLambdaFunction.Arn
AlarmName:
Description: CloudWatch Alarm Name
Value: !Ref LambdaErrorAlarm
TestCommand:
Description: AWS CLI command to test the function
Value: !Sub 'aws lambda invoke --function-name ${TestLambdaFunction} --payload "{\"test\":\"AWS DevOpsAgent validation\"}" response.json'
```
1. Nella CloudFormation console, seleziona **Carica un file modello**
1. Fai clic su **Scegli file**
1. Seleziona il `AWS-DevOpsAgent-lambda-test.yaml` file
1. Fai clic su **Avanti**
1. **Configura lo stack**:
1. **Nome dello stack**: `AWS-DevOpsAgent-Lambda-Test`
1. **Fai clic su Avanti**
1. **Configura le opzioni dello stack:**
1. **Lascia le impostazioni predefinite, fai clic su Avanti**
1. **Revisione e creazione**:
1. Seleziona **Riconosco che AWS CloudFormation potrebbe creare risorse** IAM
1. Fai clic su **Invia**
1. **Attendi il completamento**:
1. La creazione dello stack richiede 2-3 minuti
1. Lo stato cambierà in `CREATE_COMPLETE`
### Fase 2: Attivazione degli errori Lambda
1. **Vai alla console Lambda:**
1. Vai alla console **AWS Lambda**
1. Trova la tua funzione `AWS-DevOpsAgent-test-lambda`
1. **Prova la funzione**:
1. Fate clic sulla scheda **Test**
1. Fai clic su **Crea nuovo evento**
1. **Nome dell'evento**: `AWS-DevOpsAgent-test-event`
1. Usa questo payload JSON:
1.
```
{
"test": "AWS DevOpsAgent validation",
"timestamp": "2024-01-01T00:00:00Z"
}
```
1. **Fai clic su Salva**
1. **Genera errori**:
1. Fai clic sul pulsante **Test** 3 volte (attendi 10 secondi tra una e l'altra)
1. Ogni test genererà un errore intenzionale
1. **CloudWatch l'allarme** dovrebbe attivarsi entro 2-3 minuti
1. **AWS DevOpsAgent**ora dovrebbe essere in grado di rilevare l'allarme con un'**indagine** nell'**app Operator** che configurerai successivamente.
## Convalida il rilevamento AWS DevOps dell'agente
### Fase 1: CloudWatch allarmi Sanity Check (opzionale)
Questo passaggio serve a garantire che i test precedenti siano ora in uno stato di allarme.
**Per il test EC2:**
+ **Nella CloudWatch console, vai a Allarmi**
+ **Attendere 3-5 minuti** dopo l'inizio dello stress test
+ La sveglia dovrebbe apparire **in stato di allarme**
+ **Se è ancora «OK»**: attendi altri 2-3 minuti (le CloudWatch metriche possono subire ritardi)
**Per il test Lambda:**
+ Controlla l'allarme `AWS-DevOpsAgent-Lambda-Error-Test`
+ Dovrebbe apparire **In alarm** entro 2-3 minuti dall'esecuzione dei test
### Fase 2: Avviare un'indagine su un AWS DevOps agente
1. Apri il tuo **AWS DevOps agente AgentSpace**
1. Fai clic su **Accesso amministratore**. Si aprirà l'app web DevOps Agent Space in una nuova finestra
1. Fai clic sul pulsante **Avvia indagine** sul lato destro dello schermo
1. Compila il seguente modulo:
1. **Dettagli dell'indagine:** descrivi l'indagine che desideri condurre. Includi tutti i dettagli possibili sugli obiettivi dell'indagine, sulle aree da esplorare o sulle informazioni pertinenti.
1. **Punto di inizio dell'indagine**: descrivi le informazioni da cui desideri iniziare l'indagine. Puoi menzionare un allarme, una metrica, un frammento di registro o qualsiasi altra cosa per dare all' DevOps Agent un punto di partenza su cui lavorare. In questo caso, fornisci un riepilogo degli allarmi che hai appena creato.
1. **Data e ora dell'incidente** (preferibilmente ISO 8601) ::MMZ YYYY-MM-DDTHH
1. Assegna un **nome alla tua indagine: esempio**: `Oncall_investigation_1:2025-10-27`
1. **AWS ID dell'account** per l'incidente
1. **Regione** in cui si è verificato l'incidente
1. **Priorità**: AWS DevOpsAgent consente due indagini simultanee. La priorità consente di definire l'ordine di esecuzione delle indagini.
1. Fate clic su Indagate per avviare l'indagine.
1. Fai clic sulla tua indagine elencata nella dashboard. Verrai indirizzato alla schermata Dettagli dell'indagine, dove potrai visualizzare i passaggi dettagliati che l' DevOps agente sta eseguendo.
### Risultati attesi
#### Risultati del test EC2:
+ Rileva l'allarme della CPU EC2
+ Identifica la causa principale: «carico di lavoro dello stress test della CPU»
+ Mostra la sequenza temporale: Stress test → Picco della CPU → Allarme
+ Fornisce consigli per il monitoraggio e la scalabilità
**Risultati del test Lambda:**
+ Rileva il picco del tasso di errore Lambda
+ Identifica la causa principale: «eccezioni intenzionali nei test»
+ Mostra la sequenza temporale: Invocazioni di funzioni → Errori → Allarme
+ Fornisce consigli per la gestione e il monitoraggio degli errori
## Istruzioni per la pulizia
### Test di pulizia A (test EC2)
#### Pulizia automatica
+ L'istanza verrà terminata automaticamente dopo 2 ore (integrata nel CloudFormation modello)
#### Pulizia manuale (immediata)
1. **Elimina CloudFormation stack:**
1. Vai alla console CloudFormation
1. Seleziona `AWS-DevOpsAgent-EC2-Test` pila
1. **Fai clic su Elimina**
1. Conferma l'eliminazione
1. **Questo eliminerà automaticamente tutte le risorse**: istanza EC2, gruppo di sicurezza, key pair e alarm CloudWatch
### Test di pulizia B (test Lambda)
1. **Elimina stack CloudFormation **:
1. Vai alla console CloudFormation
1. Seleziona `AWS-DevOpsAgent-Lambda-Test` pila
1. **Fai clic su Elimina**
1. Conferma l'eliminazione
1. **Questo eliminerà automaticamente tutte le risorse**: funzione Lambda, ruolo IAM e allarme CloudWatch
## Risoluzione dei problemi
### Problemi comuni
#### «Impossibile connettersi all'istanza EC2»
+ **Verifica il gruppo di sicurezza**: assicurati che SSH (porta 22) sia aperto al tuo IP
+ **Controlla le autorizzazioni chiave: Esegui** `chmod 400 AWS-DevOpsAgent-test-key.pem`
+ **Verifica IP pubblico**: all'istanza deve essere assegnato un IP pubblico
+ **Attendi l'istanza**: assicurati che l'istanza sia nello stato «In esecuzione»
#### «Allarme non si attiva»
+ **Attendi la visualizzazione delle metriche**: la CloudWatch visualizzazione delle metriche può richiedere 2-5 minuti
+ **Controlla il carico della CPU: invia** SSH all'istanza ed esegui per verificare che la CPU `top` sia superiore al 70%
+ **Verifica lo stress test**: esegui `ps aux | grep yes` per vedere se i processi di caricamento sono in esecuzione
+ **Attesa prolungata**: a volte occorrono fino a 7-8 minuti per attivare il primo allarme
## Convalida dei test
Il test AWS DevOp dell'agente ha esito positivo quando:
### Validazione tecnica
+ **Precisione dell'indagine**: i risultati del test EC2 dovrebbero indicare correttamente che l'allarme è stato attivato a causa del carico della CPU. Il risultato del test Lambda dovrebbe indicare che si è trattato di un errore intenzionale.
+ **Precisione della sequenza temporale**: viene mostrata la sequenza corretta degli eventi
+ **Qualità della raccomandazione**: vengono forniti suggerimenti attuabili