Perguntas de entrevista para engenheiro cloud júnior AWS

# Exemplos da AWS CLI

# Parar uma instância
aws ec2 stop-instances --instance-ids i-1234567890abcdef0

# Iniciar uma instância parada
aws ec2 start-instances --instance-ids i-1234567890abcdef0

# Encerrar uma instância
aws ec2 terminate-instances --instance-ids i-1234567890abcdef0

# Criar bucket S3
aws s3 mb s3://my-bucket-name

# Enviar arquivo
aws s3 cp myfile.txt s3://my-bucket-name/

# Listar objetos
aws s3 ls s3://my-bucket-name/

# Baixar arquivo
aws s3 cp s3://my-bucket-name/myfile.txt ./

# Criar grupo de segurança
aws ec2 create-security-group \
  --group-name web-sg \
  --description "Grupo de segurança do servidor web" \
  --vpc-id vpc-1234567890abcdef0

# Adicionar regra de entrada (permitir HTTP)
aws ec2 authorize-security-group-ingress \
  --group-id sg-0123456789abcdef0 \
  --protocol tcp \
  --port 80 \
  --cidr 0.0.0.0/0

# Adicionar regra de entrada (permitir SSH de IP específico)
aws ec2 authorize-security-group-ingress \
  --group-id sg-0123456789abcdef0 \
  --protocol tcp \
  --port 22 \
  --cidr 203.0.113.0/24

// Exemplo de Política IAM (somente leitura do S3)
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::my-bucket",
        "arn:aws:s3:::my-bucket/*"
      ]
    }
  ]
}

# Iniciar instâncias em várias AZs
aws ec2 run-instances \
  --image-id ami-0abcdef1234567890 \
  --instance-type t2.micro \
  --subnet-id subnet-1a \
  --count 1

aws ec2 run-instances \
  --image-id ami-0abcdef1234567890 \
  --instance-type t2.micro \
  --subnet-id subnet-1b \
  --count 1

# Criar AMI a partir da instância em execução
aws ec2 create-image \
  --instance-id i-1234567890abcdef0 \
  --name "My-Web-Server-AMI" \
  --description "Servidor web com Apache configurado"

# Iniciar instância a partir da AMI
aws ec2 run-instances \
  --image-id ami-0abcdef1234567890 \
  --instance-type t2.micro \
  --key-name my-key-pair

# Criar volume EBS
aws ec2 create-volume \
  --availability-zone us-east-1a \
  --size 100 \
  --volume-type gp3 \
  --iops 3000 \
  --throughput 125

# Anexar à instância
aws ec2 attach-volume \
  --volume-id vol-1234567890abcdef0 \
  --instance-id i-1234567890abcdef0 \
  --device /dev/sdf

# Formatar e montar (na instância)
sudo mkfs -t ext4 /dev/sdf
sudo mkdir /data
sudo mount /dev/sdf /data

# Tornar permanente (adicionar a /etc/fstab)
echo "/dev/sdf /data ext4 defaults,nofail 0 2" | sudo tee -a /etc/fstab

# Criar snapshot
aws ec2 create-snapshot \
  --volume-id vol-1234567890abcdef0 \
  --description "Backup antes da atualização"

# Restaurar a partir do snapshot
aws ec2 create-volume \
  --snapshot-id snap-1234567890abcdef0 \
  --availability-zone us-east-1a \
  --volume-type gp3

# Copiar snapshot para outra região
aws ec2 copy-snapshot \
  --source-region us-east-1 \
  --source-snapshot-id snap-1234567890abcdef0 \
  --destination-region us-west-2

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject"
      ],
      "Resource": "arn:aws:s3:::my-bucket/*"
    }
  ]
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadGetObject",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::my-public-bucket/*"
    },
    {
      "Sid": "RestrictByIP",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": [
        "arn:aws:s3:::my-bucket",
        "arn:aws:s3:::my-bucket/*"
      ],
      "Condition": {
        "NotIpAddress": {
          "aws:SourceIp": "203.0.113.0/24"
        }
      }
    }
  ]
}

# Criar arquivo de política (policy.json)
# Em seguida, aplique-o
aws s3api put-bucket-policy \
  --bucket my-bucket \
  --policy file://policy.json

# Visualizar política atual
aws s3api get-bucket-policy \
  --bucket my-bucket

# Excluir política
aws s3api delete-bucket-policy \
  --bucket my-bucket

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::my-website/*"
    }
  ]
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:root"
      },
      "Action": "s3:*",
      "Resource": [
        "arn:aws:s3:::shared-bucket",
        "arn:aws:s3:::shared-bucket/*"
      ]
    }
  ]
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::my-bucket/*",
      "Condition": {
        "StringNotEquals": {
          "s3:x-amz-server-side-encryption": "AES256"
        }
      }
    }
  ]
}

# Visualizar métricas de CPU do EC2
aws cloudwatch get-metric-statistics \
  --namespace AWS/EC2 \
  --metric-name CPUUtilization \
  --dimensions Name=InstanceId,Value=i-1234567890abcdef0 \
  --start-time 2024-11-25T00:00:00Z \
  --end-time 2024-11-25T23:59:59Z \
  --period 3600 \
  --statistics Average,Maximum

# Publicar métrica personalizada
aws cloudwatch put-metric-data \
  --namespace MyApp \
  --metric-name PageLoadTime \
  --value 0.5 \
  --unit Seconds

# Criar alarme para CPU alta
aws cloudwatch put-metric-alarm \
  --alarm-name high-cpu-alarm \
  --alarm-description "Alerta quando a CPU exceder 80%" \
  --metric-name CPUUtilization \
  --namespace AWS/EC2 \
  --statistic Average \
  --period 300 \
  --threshold 80 \
  --comparison-operator GreaterThanThreshold \
  --evaluation-periods 2 \
  --dimensions Name=InstanceId,Value=i-1234567890abcdef0 \
  --alarm-actions arn:aws:sns:us-east-1:123456789012:my-topic

# Criar grupo de logs
aws logs create-log-group \
  --log-group-name /aws/application/myapp

# Criar fluxo de logs
aws logs create-log-stream \
  --log-group-name /aws/application/myapp \
  --log-stream-name instance-1

# Colocar eventos de log
aws logs put-log-events \
  --log-group-name /aws/application/myapp \
  --log-stream-name instance-1 \
  --log-events \
    timestamp=1234567890000,message="Aplicativo iniciado" \
    timestamp=1234567891000,message="Solicitação de processamento"

# Consultar logs
aws logs filter-log-events \
  --log-group-name /aws/application/myapp \
  --filter-pattern "ERROR" \
  --start-time 1234567890000

# Criar painel com boto3
import boto3
import json

cloudwatch = boto3.client('cloudwatch')

dashboard_body = {
    "widgets": [
        {
            "type": "metric",
            "properties": {
                "metrics": [
                    ["AWS/EC2", "CPUUtilization", {"stat": "Average"}]
                ],
                "period": 300,
                "stat": "Average",
                "region": "us-east-1",
                "title": "Utilização da CPU do EC2"
            }
        },
        {
            "type": "metric",
            "properties": {
                "metrics": [
                    ["AWS/RDS", "DatabaseConnections"]
                ],
                "period": 300,
                "stat": "Sum",
                "region": "us-east-1",
                "title": "Conexões RDS"
            }
        }
    ]
}

cloudwatch.put_dashboard(
    DashboardName='MyAppDashboard',
    DashboardBody=json.dumps(dashboard_body)
)

# As métricas de CPU, Rede e Disco são automáticas
# Para memória, precisa do agente CloudWatch

# Instalar agente CloudWatch
wget https://s3.amazonaws.com/amazoncloudwatch-agent/amazon_linux/amd64/latest/amazon-cloudwatch-agent.rpm
sudo rpm -U ./amazon-cloudwatch-agent.rpm

# Configurar agente (cria arquivo de configuração)
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-config-wizard

# Iniciar agente
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \
  -a fetch-config \
  -m ec2 \
  -s \
  -c file:/opt/aws/amazon-cloudwatch-agent/bin/config.json

# Aplicativo Python com registro CloudWatch
import boto3
import logging
from datetime import datetime

class CloudWatchHandler(logging.Handler):
    def __init__(self, log_group, log_stream):
        super().__init__()
        self.client = boto3.client('logs')
        self.log_group = log_group
        self.log_stream = log_stream
        
    def emit(self, record):
        log_entry = self.format(record)
        self.client.put_log_events(
            logGroupName=self.log_group,
            logStreamName=self.log_stream,
            logEvents=[{
                'timestamp': int(datetime.now().timestamp() * 1000),
                'message': log_entry
            }]
        )

# Uso
logger = logging.getLogger()
logger.addHandler(CloudWatchHandler('/aws/myapp', 'instance-1'))
logger.info("Aplicativo iniciado")