// لیست کامل خدمات AWS با کد راه‌اندازی اولیه

// ۱. EC2 (Elastic Compute Cloud)
const AWS = require('aws-sdk');
const ec2 = new AWS.EC2();

const runEC2Instance = async () => {
  const params = {
    ImageId: 'ami-0c55b159cbfafe1f0',
    InstanceType: 't2.micro',
    MinCount: 1,
    MaxCount: 1,
    KeyName: 'my-key-pair',
    SecurityGroupIds: ['sg-12345678']
  };
  
  try {
    const data = await ec2.runInstances(params).promise();
    console.log('EC2 Instance created:', data.Instances[0].InstanceId);
    return data.Instances[0].InstanceId;
  } catch (err) {
    console.error('Error creating EC2 instance:', err);
    throw err;
  }
};

// ۲. Lightsail
const lightsail = new AWS.Lightsail();

const createLightsailInstance = async () => {
  const params = {
    instanceNames: ['MyWebsite'],
    availabilityZone: 'us-east-1a',
    blueprintId: 'wordpress',
    bundleId: 'nano_2_0'
  };
  
  try {
    const data = await lightsail.createInstances(params).promise();
    console.log('Lightsail instance created:', data);
    return data;
  } catch (err) {
    console.error('Error creating Lightsail instance:', err);
    throw err;
  }
};

// ۳. Lambda
const lambda = new AWS.Lambda();

const createLambdaFunction = async () => {
  const fs = require('fs');
  const functionCode = fs.readFileSync('lambda_function.zip');
  
  const params = {
    Code: {
      ZipFile: functionCode
    },
    FunctionName: 'myFunction',
    Handler: 'index.handler',
    Role: 'arn:aws:iam::123456789012:role/lambda-role',
    Runtime: 'nodejs14.x',
    Description: 'My Lambda Function'
  };
  
  try {
    const data = await lambda.createFunction(params).promise();
    console.log('Lambda function created:', data.FunctionArn);
    return data.FunctionArn;
  } catch (err) {
    console.error('Error creating Lambda function:', err);
    throw err;
  }
};

// ۴. Elastic Beanstalk
const elasticBeanstalk = new AWS.ElasticBeanstalk();

const createBeanstalkApp = async () => {
  // ایجاد برنامه
  const appParams = {
    ApplicationName: 'myApplication',
    Description: 'My application description'
  };
  
  try {
    await elasticBeanstalk.createApplication(appParams).promise();
    
    // ایجاد محیط
    const envParams = {
      ApplicationName: 'myApplication',
      EnvironmentName: 'myEnvironment',
      SolutionStackName: '64bit Amazon Linux 2 v5.4.4 running Node.js 14',
      OptionSettings: [
        {
          Namespace: 'aws:autoscaling:launchconfiguration',
          OptionName: 'InstanceType',
          Value: 't2.micro'
        }
      ]
    };
    
    const envData = await elasticBeanstalk.createEnvironment(envParams).promise();
    console.log('Beanstalk environment created:', envData.EnvironmentId);
    return envData.EnvironmentId;
  } catch (err) {
    console.error('Error creating Beanstalk application:', err);
    throw err;
  }
};

// ۵. ECR (Elastic Container Registry)
const ecr = new AWS.ECR();

const createECRRepository = async () => {
  const params = {
    repositoryName: 'my-repo',
    imageScanningConfiguration: {
      scanOnPush: true
    }
  };
  
  try {
    const data = await ecr.createRepository(params).promise();
    console.log('ECR repository created:', data.repository.repositoryUri);
    return data.repository.repositoryUri;
  } catch (err) {
    console.error('Error creating ECR repository:', err);
    throw err;
  }
};

// ۶. S3 (Simple Storage Service)
const s3 = new AWS.S3();

const createS3Bucket = async () => {
  const params = {
    Bucket: 'my-unique-bucket-name',
    CreateBucketConfiguration: {
      LocationConstraint: 'us-west-2'
    }
  };
  
  try {
    const data = await s3.createBucket(params).promise();
    console.log('S3 bucket created:', data.Location);
    return data.Location;
  } catch (err) {
    console.error('Error creating S3 bucket:', err);
    throw err;
  }
};

// ۷. EBS (Elastic Block Store)
const createEBSVolume = async () => {
  const params = {
    AvailabilityZone: 'us-east-1a',
    Size: 10,
    VolumeType: 'gp2'
  };
  
  try {
    const data = await ec2.createVolume(params).promise();
    console.log('EBS volume created:', data.VolumeId);
    return data.VolumeId;
  } catch (err) {
    console.error('Error creating EBS volume:', err);
    throw err;
  }
};

// ۸. EFS (Elastic File System)
const efs = new AWS.EFS();

const createEFSFileSystem = async () => {
  const params = {
    PerformanceMode: 'generalPurpose',
    Encrypted: true,
    Tags: [
      {
        Key: 'Name',
        Value: 'MyFileSystem'
      }
    ]
  };
  
  try {
    const data = await efs.createFileSystem(params).promise();
    console.log('EFS file system created:', data.FileSystemId);
    return data.FileSystemId;
  } catch (err) {
    console.error('Error creating EFS file system:', err);
    throw err;
  }
};

// ۹. Glacier
const glacier = new AWS.Glacier();

const createGlacierVault = async () => {
  const params = {
    vaultName: 'my-archive-vault',
    accountId: '-' // از '-' برای استفاده از اکانت جاری استفاده می‌شود
  };
  
  try {
    const data = await glacier.createVault(params).promise();
    console.log('Glacier vault created:', data.location);
    return data.location;
  } catch (err) {
    console.error('Error creating Glacier vault:', err);
    throw err;
  }
};

// ۱۰. VPC (Virtual Private Cloud)
const createVPC = async () => {
  const params = {
    CidrBlock: '10.0.0.0/16',
    TagSpecifications: [
      {
        ResourceType: 'vpc',
        Tags: [
          {
            Key: 'Name',
            Value: 'MyVPC'
          }
        ]
      }
    ]
  };
  
  try {
    const data = await ec2.createVpc(params).promise();
    console.log('VPC created:', data.Vpc.VpcId);
    return data.Vpc.VpcId;
  } catch (err) {
    console.error('Error creating VPC:', err);
    throw err;
  }
};

// ۱۱. Route 53
const route53 = new AWS.Route53();

const createHostedZone = async () => {
  const params = {
    Name: 'example.com.',
    CallerReference: String(Date.now())
  };
  
  try {
    const data = await route53.createHostedZone(params).promise();
    console.log('Hosted zone created:', data.HostedZone.Id);
    return data.HostedZone.Id;
  } catch (err) {
    console.error('Error creating hosted zone:', err);
    throw err;
  }
};

// ۱۲. Elastic Load Balancer
const elb = new AWS.ELBv2();

const createLoadBalancer = async () => {
  const params = {
    Name: 'my-load-balancer',
    Subnets: ['subnet-12345678', 'subnet-87654321'],
    SecurityGroups: ['sg-12345678'],
    Scheme: 'internet-facing',
    Type: 'application'
  };
  
  try {
    const data = await elb.createLoadBalancer(params).promise();
    console.log('Load balancer created:', data.LoadBalancers[0].LoadBalancerArn);
    return data.LoadBalancers[0].LoadBalancerArn;
  } catch (err) {
    console.error('Error creating load balancer:', err);
    throw err;
  }
};

// ۱۳. CloudFront
const cloudfront = new AWS.CloudFront();

const createCloudFrontDistribution = async () => {
  const params = {
    DistributionConfig: {
      CallerReference: String(Date.now()),
      Origins: {
        Quantity: 1,
        Items: [
          {
            Id: 'S3Origin',
            DomainName: 'my-bucket.s3.amazonaws.com',
            S3OriginConfig: {
              OriginAccessIdentity: ''
            }
          }
        ]
      },
      DefaultCacheBehavior: {
        TargetOriginId: 'S3Origin',
        ViewerProtocolPolicy: 'redirect-to-https',
        MinTTL: 0,
        DefaultTTL: 86400,
        MaxTTL: 31536000,
        ForwardedValues: {
          QueryString: false,
          Cookies: { Forward: 'none' }
        }
      },
      Enabled: true,
      Comment: 'My CDN Distribution'
    }
  };
  
  try {
    const data = await cloudfront.createDistribution(params).promise();
    console.log('CloudFront distribution created:', data.Distribution.Id);
    return data.Distribution.Id;
  } catch (err) {
    console.error('Error creating CloudFront distribution:', err);
    throw err;
  }
};

// ۱۴. IAM (Identity & Access Management)
const iam = new AWS.IAM();

const createIAMUser = async () => {
  const params = {
    UserName: 'new-user'
  };
  
  try {
    const data = await iam.createUser(params).promise();
    console.log('IAM user created:', data.User.UserName);
    return data.User.UserName;
  } catch (err) {
    console.error('Error creating IAM user:', err);
    throw err;
  }
};

// ۱۵. Organizations
const organizations = new AWS.Organizations();

const createOrganization = async () => {
  const params = {
    FeatureSet: 'ALL'
  };
  
  try {
    const data = await organizations.createOrganization(params).promise();
    console.log('Organization created:', data.Organization.Id);
    return data.Organization.Id;
  } catch (err) {
    console.error('Error creating organization:', err);
    throw err;
  }
};

// ۱۶. CloudTrail
const cloudtrail = new AWS.CloudTrail();

const createTrail = async () => {
  const params = {
    Name: 'management-events',
    S3BucketName: 'my-trail-bucket',
    IsMultiRegionTrail: true,
    EnableLogFileValidation: true,
    IncludeGlobalServiceEvents: true
  };
  
  try {
    const data = await cloudtrail.createTrail(params).promise();
    console.log('CloudTrail created:', data.TrailARN);
    return data.TrailARN;
  } catch (err) {
    console.error('Error creating CloudTrail:', err);
    throw err;
  }
};

// ۱۷. CloudWatch
const cloudwatch = new AWS.CloudWatch();

const createCloudWatchAlarm = async () => {
  const params = {
    AlarmName: 'high-cpu-utilization',
    ComparisonOperator: 'GreaterThanThreshold',
    EvaluationPeriods: 2,
    MetricName: 'CPUUtilization',
    Namespace: 'AWS/EC2',
    Period: 300,
    Statistic: 'Average',
    Threshold: 70.0,
    ActionsEnabled: true,
    AlarmDescription: 'Alarm when CPU exceeds 70%',
    Dimensions: [
      {
        Name: 'InstanceId',
        Value: 'i-12345678901234567'
      }
    ]
  };
  
  try {
    const data = await cloudwatch.putMetricAlarm(params).promise();
    console.log('CloudWatch alarm created');
    return 'high-cpu-utilization';
  } catch (err) {
    console.error('Error creating CloudWatch alarm:', err);
    throw err;
  }
};

// ۱۸. SNS (Simple Notification Service)
const sns = new AWS.SNS();

const createSNSTopic = async () => {
  const params = {
    Name: 'alerts'
  };
  
  try {
    const data = await sns.createTopic(params).promise();
    console.log('SNS topic created:', data.TopicArn);
    return data.TopicArn;
  } catch (err) {
    console.error('Error creating SNS topic:', err);
    throw err;
  }
};

// ۱۹. SES (Simple Email Service)
const ses = new AWS.SES();

const verifyEmailIdentity = async () => {
  const params = {
    EmailAddress: '[email protected]'
  };
  
  try {
    const data = await ses.verifyEmailIdentity(params).promise();
    console.log('Email verification initiated');
    return '[email protected]';
  } catch (err) {
    console.error('Error verifying email identity:', err);
    throw err;
  }
};

// ۲۰. SQS (Simple Queue Service)
const sqs = new AWS.SQS();

const createSQSQueue = async () => {
  const params = {
    QueueName: 'my-queue',
    Attributes: {
      DelaySeconds: '0',
      MessageRetentionPeriod: '86400' // 1 روز
    }
  };
  
  try {
    const data = await sqs.createQueue(params).promise();
    console.log('SQS queue created:', data.QueueUrl);
    return data.QueueUrl;
  } catch (err) {
    console.error('Error creating SQS queue:', err);
    throw err;
  }
};

// ۲۱. Kinesis
const kinesis = new AWS.Kinesis();

const createKinesisStream = async () => {
  const params = {
    ShardCount: 1,
    StreamName: 'my-data-stream'
  };
  
  try {
    const data = await kinesis.createStream(params).promise();
    console.log('Kinesis stream created');
    return 'my-data-stream';
  } catch (err) {
    console.error('Error creating Kinesis stream:', err);
    throw err;
  }
};

// ۲۲. RDS (Relational Database Service)
const rds = new AWS.RDS();

const createRDSInstance = async () => {
  const params = {
    DBName: 'mydb',
    DBInstanceIdentifier: 'my-db-instance',
    AllocatedStorage: 20,
    DBInstanceClass: 'db.t2.micro',
    Engine: 'mysql',
    MasterUsername: 'admin',
    MasterUserPassword: 'password123',
    VpcSecurityGroupIds: ['sg-12345678'],
    BackupRetentionPeriod: 7,
    Port: 3306,
    MultiAZ: false,
    EngineVersion: '8.0.28',
    PubliclyAccessible: false
  };
  
  try {
    const data = await rds.createDBInstance(params).promise();
    console.log('RDS instance created:', data.DBInstance.DBInstanceIdentifier);
    return data.DBInstance.DBInstanceIdentifier;
  } catch (err) {
    console.error('Error creating RDS instance:', err);
    throw err;
  }
};

// ۲۳. Aurora
const createAuroraCluster = async () => {
  const params = {
    DBClusterIdentifier: 'my-aurora-cluster',
    Engine: 'aurora-mysql',
    EngineVersion: '5.7.mysql_aurora.2.10.2',
    MasterUsername: 'admin',
    MasterUserPassword: 'password123',
    DatabaseName: 'mydb',
    VpcSecurityGroupIds: ['sg-12345678']
  };
  
  try {
    const data = await rds.createDBCluster(params).promise();
    console.log('Aurora cluster created:', data.DBCluster.DBClusterIdentifier);
    return data.DBCluster.DBClusterIdentifier;
  } catch (err) {
    console.error('Error creating Aurora cluster:', err);
    throw err;
  }
};

// ۲۴. DynamoDB
const dynamodb = new AWS.DynamoDB();

const createDynamoDBTable = async () => {
  const params = {
    TableName: 'Users',
    KeySchema: [
      { AttributeName: 'user_id', KeyType: 'HASH' },
      { AttributeName: 'email', KeyType: 'RANGE' }
    ],
    AttributeDefinitions: [
      { AttributeName: 'user_id', AttributeType: 'S' },
      { AttributeName: 'email', AttributeType: 'S' }
    ],
    ProvisionedThroughput: {
      ReadCapacityUnits: 5,
      WriteCapacityUnits: 5
    }
  };
  
  try {
    const data = await dynamodb.createTable(params).promise();
    console.log('DynamoDB table created:', data.TableDescription.TableName);
    return data.TableDescription.TableName;
  } catch (err) {
    console.error('Error creating DynamoDB table:', err);
    throw err;
  }
};

// ۲۵. Elasticache
const elasticache = new AWS.ElastiCache();

const createElasticacheCluster = async () => {
  const params = {
    CacheClusterId: 'my-redis',
    Engine: 'redis',
    EngineVersion: '6.x',
    CacheNodeType: 'cache.t2.micro',
    NumCacheNodes: 1,
    CacheSubnetGroupName: 'my-cache-subnet',
    SecurityGroupIds: ['sg-12345678']
  };
  
  try {
    const data = await elasticache.createCacheCluster(params).promise();
    console.log('Elasticache cluster created:', data.CacheClusterId);
    return data.CacheClusterId;
  } catch (err) {
    console.error('Error creating Elasticache cluster:', err);
    throw err;
  }
};

// ۲۶. Redshift
const redshift = new AWS.Redshift();

const createRedshiftCluster = async () => {
  const params = {
    ClusterIdentifier: 'my-redshift-cluster',
    NodeType: 'dc2.large',
    MasterUsername: 'admin',
    MasterUserPassword: 'Password123',
    DBName: 'mydw',
    ClusterType: 'single-node',
    VpcSecurityGroupIds: ['sg-12345678'],
    PubliclyAccessible: false,
    Encrypted: true
  };
  
  try {
    const data = await redshift.createCluster(params).promise();
    console.log('Redshift cluster created:', data.Cluster.ClusterIdentifier);
    return data.Cluster.ClusterIdentifier;
  } catch (err) {
    console.error('Error creating Redshift cluster:', err);
    throw err;
  }
};

// ۲۷. AppSync (GraphQL API)
const appsync = new AWS.AppSync();

const createAppSyncAPI = async () => {
  const params = {
    name: 'MyGraphQLAPI',
    authenticationType: 'API_KEY'
  };
  
  try {
    const data = await appsync.createGraphqlApi(params).promise();
    console.log('AppSync API created:', data.graphqlApi.apiId);
    return data.graphqlApi.apiId;
  } catch (err) {
    console.error('Error creating AppSync API:', err);
    throw err;
  }
};

// ۲۸. API Gateway
const apigateway = new AWS.APIGateway();

const createAPIGateway = async () => {
  const params = {
    name: 'my-api',
    description: 'My REST API',
    endpointConfiguration: {
      types: ['REGIONAL']
    }
  };
  
  try {
    const data = await apigateway.createRestApi(params).promise();
    console.log('API Gateway created:', data.id);
    return data.id;
  } catch (err) {
    console.error('Error creating API Gateway:', err);
    throw err;
  }
};

// ۲۹. Step Functions
const stepfunctions = new AWS.StepFunctions();

const createStateMachine = async () => {
  const definition = {
    Comment: 'A simple state machine',
    StartAt: 'HelloWorld',
    States: {
      HelloWorld: {
        Type: 'Task',
        Resource: 'arn:aws:lambda:us-east-1:123456789012:function:hello-world',
        End: true
      }
    }
  };
  
  const params = {
    definition: JSON.stringify(definition),
    name: 'MyStateMachine',
    roleArn: 'arn:aws:iam::123456789012:role/step-functions-role'
  };
  
  try {
    const data = await stepfunctions.createStateMachine(params).promise();
    console.log('Step Functions state machine created:', data.stateMachineArn);
    return data.stateMachineArn;
  } catch (err) {
    console.error('Error creating Step Functions state machine:', err);
    throw err;
  }
};

// ۳۰. EventBridge (CloudWatch Events)
const eventbridge = new AWS.EventBridge();

const createEventRule = async () => {
  const params = {
    Name: 'my-scheduled-rule',
    ScheduleExpression: 'cron(0 12 * * ? *)', // هر روز در ساعت 12 ظهر
    State: 'ENABLED'
  };
  
  try {
    const data = await eventbridge.putRule(params).promise();
    console.log('EventBridge rule created:', data.RuleArn);
    return data.RuleArn;
  } catch (err) {
    console.error('Error creating EventBridge rule:', err);
    throw err;
  }
};

// ۳۱. CodeBuild
const codebuild = new AWS.CodeBuild();

const createCodeBuildProject = async () => {
  const params = {
    name: 'my-build-project',
    source: {
      type: 'GITHUB',
      location: '<https://github.com/username/repo.git>'
    },
    artifacts: {
      type: 'NO_ARTIFACTS'
    },
    environment: {
      type: 'LINUX_CONTAINER',
      image: 'aws/codebuild/amazonlinux2-x86_64-standard:3.0',
      computeType: 'BUILD_GENERAL1_SMALL'
    },
    serviceRole: 'arn:aws:iam::123456789012:role/codebuild-role'
  };
  
  try {
    const data = await codebuild.createProject(params).promise();
    console.log('CodeBuild project created:', data.project.arn);
    return data.project.arn;
  } catch (err) {
    console.error('Error creating CodeBuild project:', err);
    throw err;
  }
};

// ۳۲. CodeDeploy
const codedeploy = new AWS.CodeDeploy();

const createCodeDeployApp = async () => {
  const params = {
    applicationName: 'my-application',
    computePlatform: 'Server'
  };
  
  try {
    const data = await codedeploy.createApplication(params).promise();
    console.log('CodeDeploy application created:', data.applicationId);
    return data.applicationId;
  } catch (err) {
    console.error('Error creating CodeDeploy application:', err);
    throw err;
  }
};

// ۳۳. CodePipeline
const codepipeline = new AWS.CodePipeline();

const createCodePipeline = async () => {
  const params = {
    pipeline: {
      name: 'my-pipeline',
      roleArn: 'arn:aws:iam::123456789012:role/codepipeline-role',
      artifactStore: {
        type: 'S3',
        location: 'my-artifact-bucket'
      },
      stages: [
        {
          name: 'Source',
          actions: [
            {
              name: 'Source',
              actionTypeId: {
                category: 'Source',
                owner: 'AWS',
                provider: 'CodeStarSourceConnection',
                version: '1'
              },
              configuration: {
                ConnectionArn: 'arn:aws:codestar-connections:us-east-1:123456789012:connection/abcdef',
                FullRepositoryId: 'username/repo',
                BranchName: 'main'
              },
              outputArtifacts: [
                {
                  name: 'SourceCode'
                }
              ]
            }
          ]
        },
        {
          name: 'Build',
          actions: [
            {
              name: 'BuildAction',
              actionTypeId: {
                category: 'Build',
                owner: 'AWS',
                provider: 'CodeBuild',
                version: '1'
              },
              configuration: {
                ProjectName: 'my-build-project'
              },
              inputArtifacts: [
                {
                  name: 'SourceCode'
                }
              ],
              outputArtifacts: [
                {
                  name: 'BuildOutput'
                }
              ]
            }
          ]
        }
      ]
    }
  };
  
  try {
    const data = await codepipeline.createPipeline(params).promise();
    console.log('CodePipeline created:', data.pipeline.name);
    return data.pipeline.name;
  } catch (err) {
    console.error('Error creating CodePipeline:', err);
    throw err;
  }
};

// ۳۴. Cognito
const cognito = new AWS.CognitoIdentityServiceProvider();

const createCognitoUserPool = async () => {
  const params = {
    PoolName: 'my-user-pool',
    AutoVerifiedAttributes: ['email'],
    UsernameAttributes: ['email']
  };
  
  try {
    const data = await cognito.createUserPool(params).promise();
    console.log('Cognito user pool created:', data.UserPool.Id);
    return data.UserPool.Id;
  } catch (err) {
    console.error('Error creating Cognito user pool:', err);
    throw err;
  }
};

// ۳۵. Secrets Manager
const secretsmanager = new AWS.SecretsManager();

const createSecret = async () => {
  const params = {
    Name: 'my/secret',
    Description: 'My database credentials',
    SecretString: JSON.stringify({
      username: 'admin',
      password: 'secret-password',
      host: 'mydb.example.com',
      port: 3306,
      dbname: 'mydb'
    })
  };
  
  try {
    const data = await secretsmanager.createSecret(params).promise();
    console.log('Secret created:', data.ARN);
    return data.ARN;
  } catch (err) {
    console.error('Error creating secret:', err);
    throw err;
  }
};

// ۳۶. Athena
const athena = new AWS.Athena();

const startAthenaQuery = async () => {
  const params = {
    QueryString: 'SELECT * FROM my_table LIMIT 10',
    QueryExecutionContext: {
      Database: 'my_database'
    },
    ResultConfiguration: {
      OutputLocation: 's3://my-query-results-bucket/results/'
    }
  };
  
  try {
    const data = await athena.startQueryExecution(params).promise();
    console.log('Athena query started:', data.QueryExecutionId);
    return data.QueryExecutionId;
  } catch (err) {
    console.error('Error starting Athena query:', err);
    throw err;
  }
};

// ۳۷. Glue
const glue = new AWS.Glue();

const createGlueJob = async () => {
  const params = {
    Name: 'my-etl-job',
    Role: 'arn:aws:iam::123456789012:role/glue-role',
    Command: {
      Name: 'glueetl',
      ScriptLocation: 's3://my-scripts/glue-job.py'
    },
    DefaultArguments: {
      '--job-language': 'python'
    },
    MaxRetries: 2,
    Timeout: 60, // minutes
    NumberOfWorkers: 2,
    WorkerType: 'G.1X'
  };
  
  try {
    const data = await glue.createJob(params).promise();
    console.log('Glue job created:', data.Name);
    return data.Name;
  } catch (err) {
    console.error('Error creating Glue job:', err);
    throw err;
  }
};

// ۳۸. EMR (Elastic MapReduce)
const emr = new AWS.EMR();

const createEMRCluster = async () => {
  const params = {
    Name: 'My Cluster',
    ReleaseLabel: 'emr-6.4.0',
    Applications: [
      { Name: 'Hadoop' },
      { Name: 'Spark' }
    ],
    Instances: {
      InstanceGroups: [
        {
          Name: 'Master',
          Market: 'ON_DEMAND',
          InstanceRole: 'MASTER',
          InstanceType: 'm5.xlarge',
          InstanceCount: 1
        },
        {
          Name: 'Workers',
          Market: 'ON_DEMAND',
          InstanceRole: 'CORE',
          InstanceType: 'm5.xlarge',
          InstanceCount: 2
        }
      ],
      Ec2KeyName: 'my-key-pair',
      KeepJobFlowAliveWhenNoSteps: true,
      TerminationProtected: false
    },
    VisibleToAllUsers: true,
    JobFlowRole: 'EMR_EC2_DefaultRole',
    ServiceRole: 'EMR_DefaultRole'
  };
  
  try {
    const data = await emr.runJobFlow(params).promise();
    console.log('EMR cluster created:', data.JobFlowId);
    return data.JobFlowId;
  } catch (err) {
    console.error('Error creating EMR cluster:', err);
    throw err;
  }
};

// ۳۹. SageMaker
const sagemaker = new AWS.SageMaker();

const createSageMakerNotebookInstance = async () => {
  const params = {
    NotebookInstanceName: 'my-notebook',
    InstanceType: 'ml.t2.medium',
    RoleArn: 'arn:aws:iam::123456789012:role/sagemaker-role',
    VolumeSizeInGB: 5
  };
  
  try {
    const data = await sagemaker.createNotebookInstance(params).promise();
    console.log('SageMaker notebook instance created:', data.NotebookInstanceArn);
    return data.NotebookInstanceArn;
  } catch (err) {
    console.error('Error creating SageMaker notebook instance:', err);
    throw err;
  }
};

// ۴۰. Comprehend
const comprehend = new AWS.Comprehend();

const detectSentiment = async () => {
  const params = {
    LanguageCode: 'en',
    Text: 'I love AWS services. They are very helpful for building scalable applications.'
  };
  
  try {
    const data = await comprehend.detectSentiment(params).promise();
    console.log('Sentiment detected:', data.Sentiment);
    return data.Sentiment;
  } catch (err) {
    console.error('Error detecting sentiment:', err);
    throw err;
  }
};

// ۴۱. Translate
const translate = new AWS.Translate();

const translateText = async () => {
  const params = {
    SourceLanguageCode: 'en',
    TargetLanguageCode: 'fr',
    Text: 'Hello, World!'
  };
  
  try {
    const data = await translate.translateText(params).promise();
    console.log('Translated text:', data.TranslatedText);
    return data.TranslatedText;
  } catch (err) {
    console.error('Error translating text:', err);
    throw err;
  }
};

// ۴۲. Rekognition
const rekognition = new AWS.Rekognition();

const detectLabelsInImage = async () => {
  const params = {
    Image: {
      S3Object: {
        Bucket: 'my-images-bucket',
        Name: 'sample.jpg'
      }
    },
    MaxLabels: 10,
    MinConfidence: 70
  };
  
  try {
    const data = await rekognition.detectLabels(params).promise();
    console.log('Labels detected:', data.Labels);
    return data.Labels;
  } catch (err) {
    console.error('Error detecting labels:', err);
    throw err;
  }
};

// ۴۳. Polly
const polly = new AWS.Polly();

const synthesizeSpeech = async () => {
  const params = {
    OutputFormat: 'mp3',
    Text: 'Hello, welcome to AWS!',
    VoiceId: 'Joanna'
  };
  
  try {
    const data = await polly.synthesizeSpeech(params).promise();
    console.log('Speech synthesized, audio length:', data.AudioStream.length);
    return data.AudioStream;
  } catch (err) {
    console.error('Error synthesizing speech:', err);
    throw err;
  }
};

// ۴۴. Lex
const lexmodelbuildingservice = new AWS.LexModelBuildingService();

const createLexBot = async () => {
  const params = {
    name: 'BookTrip',
    childDirected: false,
    locale: 'en-US',
    description: 'Bot to book a hotel or car rental',
    idleSessionTTLInSeconds: 300,
    voiceId: 'Salli',
    processBehavior: 'BUILD',
    abortStatement: {
      messages: [
        {
          contentType: 'PlainText',
          content: 'Sorry, I cannot help you at this time.'
        }
      ]
    }
  };
  
  try {
    const data = await lexmodelbuildingservice.putBot(params).promise();
    console.log('Lex bot created:', data.name);
    return data.name;
  } catch (err) {
    console.error('Error creating Lex bot:', err);
    throw err;
  }
};

// ۴۵. Neptune
const neptune = new AWS.Neptune();

const createNeptuneCluster = async () => {
  const params = {
    DBClusterIdentifier: 'my-neptune-cluster',
    Engine: 'neptune',
    VpcSecurityGroupIds: ['sg-12345678'],
    DBSubnetGroupName: 'my-db-subnet-group',
    IamAuthEnabled: true
  };
  
  try {
    const data = await neptune.createDBCluster(params).promise();
    console.log('Neptune cluster created:', data.DBCluster.DBClusterIdentifier);
    return data.DBCluster.DBClusterIdentifier;
  } catch (err) {
    console.error('Error creating Neptune cluster:', err);
    throw err;
  }
};

// ۴۶. DocumentDB
const docdb = new AWS.DocDB();

const createDocDBCluster = async () => {
  const params = {
    DBClusterIdentifier: 'my-docdb-cluster',
    Engine: 'docdb',
    MasterUsername: 'admin',
    MasterUserPassword: 'password123',
    VpcSecurityGroupIds: ['sg-12345678'],
    DBSubnetGroupName: 'my-db-subnet-group',
    BackupRetentionPeriod: 7
  };
  
  try {
    const data = await docdb.createDBCluster(params).promise();
    console.log('DocumentDB cluster created:', data.DBCluster.DBClusterIdentifier);
    return data.DBCluster.DBClusterIdentifier;
  } catch (err) {
    console.error('Error creating DocumentDB cluster:', err);
    throw err;
  }
};

// ۴۷. Elasticsearch Service
const es = new AWS.ES();

const createElasticsearchDomain = async () => {
  const params = {
    DomainName: 'my-es-domain',
    ElasticsearchVersion: '7.10',
    ElasticsearchClusterConfig: {
      InstanceType: 't3.small.elasticsearch',
      InstanceCount: 1,
      DedicatedMasterEnabled: false,
      ZoneAwarenessEnabled: false
    },
    EBSOptions: {
      EBSEnabled: true,
      VolumeType: 'gp2',
      VolumeSize: 10
    },
    AccessPolicies: JSON.stringify({
      Version: '2012-10-17',
      Statement: [
        {
          Effect: 'Allow',
          Principal: {
            AWS: '*'
          },
          Action: 'es:*',
          Resource: 'arn:aws:es:us-east-1:123456789012:domain/my-es-domain/*'
        }
      ]
    })
  };
  
  try {
    const data = await es.createElasticsearchDomain(params).promise();
    console.log('Elasticsearch domain created:', data.DomainStatus.DomainName);
    return data.DomainStatus.DomainName;
  } catch (err) {
    console.error('Error creating Elasticsearch domain:', err);
    throw err;
  }
};

// ۴۸. WAF (Web Application Firewall)
const waf = new AWS.WAFV2();

const createWAFWebACL = async () => {
  const params = {
    Name: 'my-web-acl',
    Scope: 'REGIONAL',
    DefaultAction: {
      Allow: {}
    },
    VisibilityConfig: {
      SampledRequestsEnabled: true,
      CloudWatchMetricsEnabled: true,
      MetricName: 'my-web-acl-metric'
    },
    Rules: [
      {
        Name: 'block-bad-bots',
        Priority: 1,
        Statement: {
          RateBasedStatement: {
            Limit: 100,
            AggregateKeyType: 'IP'
          }
        },
        Action: {
          Block: {}
        },
        VisibilityConfig: {
          SampledRequestsEnabled: true,
          CloudWatchMetricsEnabled: true,
          MetricName: 'block-bad-bots-metric'
        }
      }
    ]
  };
  
  try {
    const data = await waf.createWebACL(params).promise();
    console.log('WAF Web ACL created:', data.Summary.Id);
    return data.Summary.Id;
  } catch (err) {
    console.error('Error creating WAF Web ACL:', err);
    throw err;
  }
};

// ۴۹. Config
const config = new AWS.ConfigService();

const createConfigRule = async () => {
  const params = {
    ConfigRule: {
      ConfigRuleName: 'restricted-ssh',
      Description: 'Checks whether security groups allow unrestricted SSH access',
      Source: {
        Owner: 'AWS',
        SourceIdentifier: 'INCOMING_SSH_DISABLED'
      },
      Scope: {
        ComplianceResourceTypes: [
          'AWS::EC2::SecurityGroup'
        ]
      }
    }
  };
  
  try {
    const data = await config.putConfigRule(params).promise();
    console.log('Config rule created');
    return 'restricted-ssh';
  } catch (err) {
    console.error('Error creating Config rule:', err);
    throw err;
  }
};

// ۵۰. GuardDuty
const guardduty = new AWS.GuardDuty();

const enableGuardDuty = async () => {
  // ابتدا یک detector ایجاد می‌کنیم
  const createParams = {
    Enable: true
  };
  
  try {
    const data = await guardduty.createDetector(createParams).promise();
    console.log('GuardDuty detector created:', data.DetectorId);
    return data.DetectorId;
  } catch (err) {
    console.error('Error creating GuardDuty detector:', err);
    throw err;
  }
};

// ... (ادامه سرویس‌های دیگر) ...

// ۵۱. KMS (Key Management Service)
const kms = new AWS.KMS();

const createKMSKey = async () => {
  const params = {
    Description: 'My encryption key',
    KeyUsage: 'ENCRYPT_DECRYPT',
    Origin: 'AWS_KMS'
  };
  
  try {
    const data = await kms.createKey(params).promise();
    console.log('KMS key created:', data.KeyMetadata.KeyId);
    return data.KeyMetadata.KeyId;
  } catch (err) {
    console.error('Error creating KMS key:', err);
    throw err;
  }
};

// ۵۲. ACM (Certificate Manager)
const acm = new AWS.ACM();

const requestCertificate = async () => {
  const params = {
    DomainName: 'example.com',
    ValidationMethod: 'DNS',
    SubjectAlternativeNames: [
      '*.example.com'
    ]
  };
  
  try {
    const data = await acm.requestCertificate(params).promise();
    console.log('Certificate requested:', data.CertificateArn);
    return data.CertificateArn;
  } catch (err) {
    console.error('Error requesting certificate:', err);
    throw err;
  }
};

// ۵۳. Transfer Family
const transfer = new AWS.Transfer();

const createSFTPServer = async () => {
  const params = {
    EndpointType: 'PUBLIC',
    IdentityProviderType: 'SERVICE_MANAGED',
    LoggingRole: 'arn:aws:iam::123456789012:role/transfer-logging-role'
  };
  
  try {
    const data = await transfer.createServer(params).promise();
    console.log('SFTP server created:', data.ServerId);
    return data.ServerId;
  } catch (err) {
    console.error('Error creating SFTP server:', err);
    throw err;
  }
};

// ۵۴. WorkSpaces
const workspaces = new AWS.WorkSpaces();

const createWorkspace = async () => {
  const params = {
    Workspaces: [
      {
        DirectoryId: 'd-12345678ab',
        UserName: 'user1',
        BundleId: 'wsb-12345678'
      }
    ]
  };
  
  try {
    const data = await workspaces.createWorkspaces(params).promise();
    console.log('Workspace creation request submitted');
    return data.PendingRequests;
  } catch (err) {
    console.error('Error creating workspace:', err);
    throw err;
  }
};

// ۵۵. SWF (Simple Workflow Service)
const swf = new AWS.SWF();

const registerSWFDomain = async () => {
  const params = {
    name: 'my-workflow-domain',
    description: 'Domain for my workflow',
    workflowExecutionRetentionPeriodInDays: '7'
  };
  
  try {
    await swf.registerDomain(params).promise();
    console.log('SWF domain registered:', params.name);
    return params.name;
  } catch (err) {
    console.error('Error registering SWF domain:', err);
    throw err;
  }
};

// ۵۶. OpsWorks
const opsworks = new AWS.OpsWorks();

const createOpsWorksStack = async () => {
  const params = {
    Name: 'MyStack',
    Region: 'us-east-1',
    ServiceRoleArn: 'arn:aws:iam::123456789012:role/aws-opsworks-service-role',
    DefaultInstanceProfileArn: 'arn:aws:iam::123456789012:instance-profile/aws-opsworks-ec2-role',
    DefaultOs: 'Amazon Linux 2'
  };
  
  try {
    const data = await opsworks.createStack(params).promise();
    console.log('OpsWorks stack created:', data.StackId);
    return data.StackId;
  } catch (err) {
    console.error('Error creating OpsWorks stack:', err);
    throw err;
  }
};

// ۵۷. IoT Core
const iot = new AWS.Iot();

const createIoTThing = async () => {
  const params = {
    thingName: 'my-iot-device'
  };
  
  try {
    const data = await iot.createThing(params).promise();
    console.log('IoT thing created:', data.thingName);
    return data.thingName;
  } catch (err) {
    console.error('Error creating IoT thing:', err);
    throw err;
  }
};

// ۵۸. Batch
const batch = new AWS.Batch();

const createBatchComputeEnvironment = async () => {
  const params = {
    computeEnvironmentName: 'my-compute-env',
    type: 'MANAGED',
    state: 'ENABLED',
    computeResources: {
      type: 'EC2',
      minvCpus: 0,
      maxvCpus: 16,
      desiredvCpus: 0,
      instanceTypes: ['m5.large'],
      subnets: ['subnet-12345678', 'subnet-87654321'],
      securityGroupIds: ['sg-12345678'],
      instanceRole: 'ecsInstanceRole'
    },
    serviceRole: 'AWSBatchServiceRole'
  };
  
  try {
    const data = await batch.createComputeEnvironment(params).promise();
    console.log('Batch compute environment created:', data.computeEnvironmentName);
    return data.computeEnvironmentName;
  } catch (err) {
    console.error('Error creating Batch compute environment:', err);
    throw err;
  }
};

// ۵۹. WorkMail
const workmail = new AWS.WorkMail();

const createWorkMailOrganization = async () => {
  const params = {
    Name: 'my-organization',
    Alias: 'my-org',
    DirectoryId: 'd-12345678ab'
  };
  
  try {
    const data = await workmail.createOrganization(params).promise();
    console.log('WorkMail organization created:', data.OrganizationId);
    return data.OrganizationId;
  } catch (err) {
    console.error('Error creating WorkMail organization:', err);
    throw err;
  }
};

// ۶۰. AppStream
const appstream = new AWS.AppStream();

const createAppStreamFleet = async () => {
  const params = {
    Name: 'my-fleet',
    DisplayName: 'My AppStream Fleet',
    Description: 'Fleet for streaming applications',
    InstanceType: 'stream.standard.medium',
    FleetType: 'ON_DEMAND',
    VpcConfig: {
      SubnetIds: ['subnet-12345678', 'subnet-87654321'],
      SecurityGroupIds: ['sg-12345678']
    },
    ComputeCapacity: {
      DesiredInstances: 1
    },
    ImageName: 'Amazon-AppStream2-Sample-Image-03-11-2019',
    DisconnectTimeoutInSeconds: 900
  };
  
  try {
    const data = await appstream.createFleet(params).promise();
    console.log('AppStream fleet created:', data.Fleet.Name);
    return data.Fleet.Name;
  } catch (err) {
    console.error('Error creating AppStream fleet:', err);
    throw err;
  }
};

// ۶۱. QuickSight
const quicksight = new AWS.QuickSight();

const createQuickSightUser = async () => {
  const params = {
    AwsAccountId: '123456789012',
    Namespace: 'default',
    IdentityType: 'IAM',
    Email: '[email protected]',
    UserRole: 'READER',
    IamArn: 'arn:aws:iam::123456789012:user/quicksight-user'
  };
  
  try {
    const data = await quicksight.registerUser(params).promise();
    console.log('QuickSight user created:', data.User.Arn);
    return data.User.Arn;
  } catch (err) {
    console.error('Error creating QuickSight user:', err);
    throw err;
  }
};

// ۶۲. AppSync (For Frontend)
const createAppSyncClientConfig = async () => {
  // فرض کنید API ID را از قبل دارید
  const apiId = 'abcdefghijklmn';
  const region = 'us-east-1';
  
  const config = {
    aws_appsync_graphqlEndpoint: `https://${apiId}.appsync-api.${region}.amazonaws.com/graphql`,
    aws_appsync_region: region,
    aws_appsync_authenticationType: 'API_KEY',
    aws_appsync_apiKey: 'da2-abcdefghijklmnopqrstuvwxyz'
  };
  
  console.log('AppSync client config created:', config);
  return config;
};

// ۶۳. Amplify
const amplify = new AWS.Amplify();

const createAmplifyApp = async () => {
  const params = {
    name: 'my-react-app',
    repository: '<https://github.com/username/my-repo>',
    platform: 'WEB',
    iamServiceRoleArn: 'arn:aws:iam::123456789012:role/amplify-role',
    buildSpec: 'version: 1\\nfrontend:\\n  phases:\\n    build:\\n      commands:\\n        - npm install\\n        - npm run build\\n  artifacts:\\n    baseDirectory: build\\n    files:\\n      - "**/*"\\n'
  };
  
  try {
    const data = await amplify.createApp(params).promise();
    console.log('Amplify app created:', data.app.appId);
    return data.app.appId;
  } catch (err) {
    console.error('Error creating Amplify app:', err);
    throw err;
  }
};

// ۶۴. CloudFormation
const cloudformation = new AWS.CloudFormation();

const createCloudFormationStack = async () => {
  const templateBody = `
    {
      "AWSTemplateFormatVersion": "2010-09-09",
      "Resources": {
        "S3Bucket": {
          "Type": "AWS::S3::Bucket",
          "Properties": {
            "BucketName": "my-cfn-bucket-${Date.now()}",
            "AccessControl": "Private",
            "VersioningConfiguration": {
              "Status": "Enabled"
            }
          }
        }
      },
      "Outputs": {
        "BucketName": {
          "Value": {"Ref": "S3Bucket"},
          "Description": "Name of the S3 bucket"
        }
      }
    }
  `;
  
  const params = {
    StackName: 'MyS3BucketStack',
    TemplateBody: templateBody,
    Capabilities: ['CAPABILITY_IAM']
  };
  
  try {
    const data = await cloudformation.createStack(params).promise();
    console.log('CloudFormation stack created:', data.StackId);
    return data.StackId;
  } catch (err) {
    console.error('Error creating CloudFormation stack:', err);
    throw err;
  }
};

// ۶۵. Media Services (MediaConvert)
const mediaconvert = new AWS.MediaConvert();

const createMediaConvertJob = async () => {
  // ابتدا باید endpoint را بدست آوریم
  const endpoints = await mediaconvert.describeEndpoints().promise();
  const endpoint = endpoints.Endpoints[0].Url;
  
  // ایجاد کلاینت جدید با endpoint خاص
  const mediaconvertWithEndpoint = new AWS.MediaConvert({ endpoint });
  
  const params = {
    Role: 'arn:aws:iam::123456789012:role/MediaConvertRole',
    Settings: {
      Inputs: [
        {
          FileInput: 's3://my-input-bucket/input.mp4'
        }
      ],
      OutputGroups: [
        {
          Name: 'File Group',
          OutputGroupSettings: {
            Type: 'FILE_GROUP_SETTINGS',
            FileGroupSettings: {
              Destination: 's3://my-output-bucket/output/'
            }
          },
          Outputs: [
            {
              VideoDescription: {
                Width: 1280,
                Height: 720,
                CodecSettings: {
                  Codec: 'H_264',
                  H264Settings: {
                    RateControlMode: 'CBR',
                    Bitrate: 5000000
                  }
                }
              },
              AudioDescriptions: [
                {
                  CodecSettings: {
                    Codec: 'AAC',
                    AacSettings: {
                      Bitrate: 96000,
                      CodingMode: 'CODING_MODE_2_0',
                      SampleRate: 48000
                    }
                  }
                }
              ],
              ContainerSettings: {
                Container: 'MP4',
                Mp4Settings: {}
              }
            }
          ]
        }
      ]
    }
  };
  
  try {
    const data = await mediaconvertWithEndpoint.createJob(params).promise();
    console.log('MediaConvert job created:', data.Job.Id);
    return data.Job.Id;
  } catch (err) {
    console.error('Error creating MediaConvert job:', err);
    throw err;
  }
};

// ۶۶. Systems Manager
const ssm = new AWS.SSM();

const createSSMParameter = async () => {
  const params = {
    Name: '/my/parameter',
    Type: 'SecureString',
    Value: 'my-secure-value',
    Description: 'My secure parameter',
    Tags: [
      {
        Key: 'Environment',
        Value: 'Production'
      }
    ]
  };
  
  try {
    const data = await ssm.putParameter(params).promise();
    console.log('SSM parameter created:', data.Version);
    return params.Name;
  } catch (err) {
    console.error('Error creating SSM parameter:', err);
    throw err;
  }
};

// ۶۷. CDK (Cloud Development Kit)
// CDK در واقع یک فریمورک است و مستقیماً با SDK کار نمی‌کند
// یک مثال ساده برای راه‌اندازی اولیه CDK:

// اجرای این دستورات در ترمینال:
/*
npm install -g aws-cdk
mkdir my-cdk-app && cd my-cdk-app
cdk init app --language=javascript
*/

// نمونه کد CDK برای ایجاد یک بانکت S3
/*
const cdk = require('@aws-cdk/core');
const s3 = require('@aws-cdk/aws-s3');

class MyCdkStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // ایجاد یک بانکت S3
    new s3.Bucket(this, 'MyFirstBucket', {
      versioned: true,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true
    });
  }
}

module.exports = { MyCdkStack }
*/

// استفاده از کد بالا در cdk-app
/*
const cdk = require('@aws-cdk/core');
const { MyCdkStack } = require('./lib/my-cdk-stack');

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack');
*/

// اجرای دستور زیر برای deploy:
// cdk deploy

// اجرای همه کدها به عنوان نمونه
const runAllExamples = async () => {
  try {
    console.log("Starting AWS services initialization...");
    
    // اجرای چند سرویس به عنوان نمونه
    await createS3Bucket();
    await createEC2Instance();
    await createLambdaFunction();
    
    console.log("AWS services initialized successfully!");
  } catch (error) {
    console.error("Error initializing AWS services:", error);
  }
};

// فراخوانی تابع اصلی
// runAllExamples();

درک می‌کنم که می‌خواهید کامل‌ترین لیست تمامی سرویس‌ها، قابلیت‌ها، اصطلاحات و کاربردهای AWS را به زبان ساده و با توضیح دقیق، بدون حذف حتی یک گزینه داشته باشید.

نکته مهم این است که تعداد سرویس‌ها و قابلیت‌های AWS بسیار زیاد است (صدها سرویس و هزاران ویژگی)، و لیست کامل آنها با توضیحات دقیق، حجم چند صد صفحه خواهد شد. اما من تا جای ممکن اصلی‌ترین و شناخته‌شده‌ترین موارد را همراه با توضیح عامیانه و کاربرد هر کدام، برای شما آماده می‌کنم. اگر به سرویس یا اصطلاح خاصی نیاز داشتید که اینجا نیافتی، کافیه اسمش رو بنویسی تا برات توضیح بدم.

لیست جامع سرویس‌ها، قابلیت‌ها و اصطلاحات AWS با توضیح ساده و دقیق

۱. EC2 (Elastic Compute Cloud)

• معنی: سرور مجازی ابری
• کاربرد: هر نوع سایت، اپلیکیشن یا برنامه‌ رو می‌خوای روی اینترنت راه بندازی، می‌تونی اینجا یه سرور مثل لپ‌تاپ اجاره کنی، روشن بمونه و هر کاری خواستی روش انجام بدی.
• اصطلاحات:
  • Instance: همون سرور/ماشین مجازی
  • AMI: ایمیج سیستم‌عامل آماده نصب
  • Security Group: دیوار آتش مخصوص اینستنس
  • Elastic IP: آی‌پی ثابتی که می‌تونی بدی به سرورت

۲. Lightsail

• معنی: سرور ابری ساده‌تر
• کاربرد: واسه کسایی که بلد نیستن سرور پیچیده راه بندازن؛ یه سرور آماده و سریع برای سایت و اپ کم‌حجم

۳. Lambda

• معنی: اجرای کد بدون نیاز به سرور
• کاربرد: فقط کدت رو می‌دی اجرا میشه، لازم نیست نگران سرور و زیرساخت باشی. معمولا برای کارهای کوتاه یا سرویس‌های پراکنده استفاده میشه.