Tutorial - Learning Amazon-Web-Services (ITA)

amazon-web-services
#amazon-
web-
services
Sommario
Di 1
Capitolo 1: Iniziare con Amazon Web Services 2
Osservazioni 2
Versioni 2
Examples 2
Prima che sia troppo tardi 2
Capitolo 2: Amazon Cognito 4
Examples 4
Gestione dell'identità utente tramite Amazon Cognito 4
Capitolo 3: Amazon DynamoDB 7
Examples 7
DynamoDB Basic Crud Operation usando NodeJS 7
Capitolo 4: AWS CloudFormation 8
Examples 8
Script di esempio CloudFormation per creare un'istanza EC2 insieme a un gruppo di sicurezz 8
AWS CloudFormer in VPC 9
Capitolo 5: AWS Lambda 19
introduzione 19
Osservazioni 19
Examples 19
Progetto Basic Gradle Java 19
Codice Lambda di base in Java 19
Codice Lambda di base in JavaScript (NodeJs) 20
Creazione di AWS Lambda tramite la GUI Web (Java) 20
Test del codice Lambda di base 20
Aggiunta del trigger del gateway API AWS 21
Capitolo 6: Beanstalk elastico 22
Osservazioni 22
Examples 22
Introduzione al fagiolo magico elastico 22

Distribuzioni blu / verdi su fagiolo magico 23
Capitolo 7: Classe di root 25
Examples 25
La classe radice di Amazon API è la seguente. 25
Business class 30
Capitolo 8: Distribuire un'immagine del contenitore finestra mobile utilizzando ECS 33
Osservazioni 33
Examples 33
esempio-task.json 33
Distribuire un'applicazione di esempio sul servizio AWS ECS come prova del concetto 34
Segui le seguenti fasi per provare un'applicazione di esempio sul servizio AWS ECS come pr 34
Titoli di coda 39
Di
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: amazon-web-services
It is an unofficial and free amazon-web-services ebook created for educational purposes. All the
content is extracted from Stack Overflow Documentation, which is written by many hardworking
individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official amazon-web-
services.
The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.
Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to info@zzzprojects.com
https://riptutorial.com/it/home 1
Capitolo 1: Iniziare con Amazon Web
Services
Osservazioni
Questa sezione fornisce una panoramica di cosa sono i servizi web di Amazon e perché uno
sviluppatore potrebbe volerlo utilizzare.
Dovrebbe anche menzionare qualsiasi argomento di grandi dimensioni all'interno di Amazon Web
Services e collegarsi agli argomenti correlati. Poiché la Documentazione per Amazon Web
Services è nuova, potrebbe essere necessario creare versioni iniziali di tali argomenti correlati.
Versioni
Versione Data di rilascio
1.0.0 2017/01/10
Examples
Prima che sia troppo tardi
Consigli e trucchi per evitare situazioni pericolose
Istanze EC2 ed EBS
• Imposta i ruoli IAM.
A differenza dei tag, il ruolo IAM viene impostato una volta per tutte sull'istanza EC2 ( anche
dopo 4 anni )! Cerca di identificare e classificare in anticipo le tue istanze in modo da poter
assegnare loro i ruoli IAM appropriati. I ruoli IAM sono un buon modo per identificare le tue
macchine, consentiranno ad Amazon di memorizzare automaticamente le credenziali del profilo di
istanza in modo sicuro nelle tue macchine, e sarai facilmente in grado di fornire privilegi extra.
Si consideri la seguente situazione in cui si dispone di server di database e ci si rende conto che
si desidera monitorare l'utilizzo della memoria / del disco. Amazon CloudWatch non fornisce
questa metrica immediatamente e dovrai configurare privilegi extra per inviare dati personalizzati a
CloudWatch. Se si dispone di un ruolo "Database" IAM, è possibile allegare facilmente nuove
policy alle istanze del database esistenti per consentire loro di inviare report di memoria a
CloudWatch. Nessun ruolo IAM? È necessario ricreare le istanze del database o autorizzarle
singolarmente.
• Attenzione all'integrità dell'istantanea
Amazon consente di eseguire l'istantanea dei volumi EBS, tuttavia, nel caso in cui si utilizzino più
volumi sulla stessa macchina (in configurazione RAID, più volumi EBS per il database), è
impossibile garantire l'integrità di tali istantanee, che possono verificarsi in momenti diversi sul
diversi volumi EBS.
Accertarsi sempre che non siano scritti dati (arrestare la VM o utilizzare codice specifico
dell'applicazione (ad esempio db.fsyncLock() ) per assicurarsi che non db.fsyncLock() scritti dati
durante l'istantanea.
CloudWatch
• Utilizzare gli avvisi di Amazon Cloudwatch + SNS in aggiunta ai notificatori degli errori
dell'applicazione
Crea avvisi per il comportamento anomalo delle macchine e configura per inviare notifiche tramite
Amazon SNS (ad es. Indirizzi email) in caso di problemi. Avere notificatori di eccezione sulla
propria applicazione non aiuterà se il proprio server non può nemmeno essere sottoposto a ping.
D'altra parte, a parte 500 codici di errore, Amazon ha poche informazioni sulla tua applicazione e
su come dovrebbe funzionare, dovresti considerare di aggiungere il monitoraggio della salute
specifico dell'applicazione.
Leggi Iniziare con Amazon Web Services online: https://riptutorial.com/it/amazon-web-

services/topic/798/iniziare-con-amazon-web-services
Capitolo 2: Amazon Cognito
Examples
Gestione dell'identità utente tramite Amazon Cognito
var app = {};
app.signUp = function(){
app.userName = $('#userName').val();
app.password = $('#password').val();
app.email = $('#form-email').val();
app.phoneNumber = $('#form-phone').val();
app.emailRegex =
/^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.
/*
Put the User input validation logic here.
*/
if (!app.userName) {
alert("Please provide a user name");
return;
}
if (!app.password) {
alert("Please provide a password");
return;
}
if (!app.email) {
alert("Please provide an Email address");
return;
}
if(!app.emailRegex.test(app.email)){
alert("Please provide a valid Email address");
return;
}
if (!app.phoneNumber) {
alert("Please provide a Phone Number");
return;
}
AWS.config.region = 'us-east-1'; // Region

AWS.config.credentials = new AWS.CognitoIdentityCredentials({
IdentityPoolId: '...' // your identity pool id here
});
AWSCognito.config.region = 'us-east-1';
AWSCognito.config.credentials = new AWS.CognitoIdentityCredentials({
IdentityPoolId: '...' // your identity pool id here
});
// Need to provide placeholder keys unless unauthorised user access is enabled for user pool
AWSCognito.config.update({accessKeyId: 'anything', secretAccessKey: 'anything'})
var poolData = {
UserPoolId : APP_CONSTANT.USER_POOL_ID,
ClientId : APP_CONSTANT.CLIENT_ID
};
userPool = new AWSCognito.CognitoIdentityServiceProvider.CognitoUserPool(poolData);
var attributeList = [];
var dataEmail = {
Name : 'email',
Value : app.email //Email Id where the confirmation code would be sent.
};
var dataPhoneNumber = {
Name : 'phone_number',
Value : app.phoneNumber
};
var attributeEmail = new
AWSCognito.CognitoIdentityServiceProvider.CognitoUserAttribute(dataEmail);
//Uncomment below once the phone number format is confirmed
/*var attributePhoneNumber = new
AWSCognito.CognitoIdentityServiceProvider.CognitoUserAttribute(dataPhoneNumber);*/
attributeList.push(attributeEmail);
/* attributeList.push(attributePhoneNumber);*/
// Put the user id and password collected from user below for signup
userPool.signUp(app.userName, app.password, attributeList, null, function(err, result){
if (err) {
alert(err);
return;
}
cognitoUser = result.user;
// Return the user name once the user signed up, still need to confirm with confirmation code
send to mail.
$("#form-confirmCode").css("display", "block");
alert('user name is ' + cognitoUser.getUsername());
// Now since the user is signed up and pending for confirmaion, disable all the pervious input
but confirmation code.
$("#userName").prop("readonly", true);
$("#password").prop("readonly", true);
$("#form-email").prop("readonly", true);
$("#form-phone").prop("readonly", true);
$("#signUpBtn").hide();
$("#confirm-block").show();
var confirmationCode = prompt("Hello "+cognitoUser.getUsername+" Enter the confirmation code

sent to your email address.","Confirmation code here");
cognitoUser.confirmRegistration(confirmationCode,true,function(err,result){
if(err){
alert(err);
return;
}
console.log('Call Result: '+result);
});
return;
});
};
Leggi Amazon Cognito online: https://riptutorial.com/it/amazon-web-services/topic/3425/amazon-
cognito
Capitolo 3: Amazon DynamoDB
Examples
DynamoDB Basic Crud Operation usando NodeJS
let doc = require('dynamodb-doc');

let dynamo = new doc.DynamoDB();
var tblName = "MyTable";
exports.handler = (event, context, callback) => {

readOperation(context);
}
function readOperation(cnxt) {
var params = {
TableName: tblName,
Key: {
"id": "2013",
"topic": "Turn It Down, Or Else!"
},
AttributesToGet: [
"id", "client_name", "info"
],
ConsistentRead: false
};
dynamo.getItem(params, function(err, data) {
if (err) console.log("Error: "+err); // an error occurred
else {
var jsonDoc = JSON.parse(data.Item.info); // successful response
cnxt.succeed(jsonDoc);
}
});
}
Leggi Amazon DynamoDB online: https://riptutorial.com/it/amazon-web-

services/topic/6429/amazon-dynamodb
Capitolo 4: AWS CloudFormation
Examples
Script di esempio CloudFormation per creare un'istanza EC2 insieme a un
gruppo di sicurezza da associare.
Questo esempio creare un'istanza EC2 di t2.micro tipo nella regione N.Virginia esecuzione
Amazon Linux. Durante l'esecuzione, chiederà di selezionare KeyPair da utilizzare e un CIDR IP
da cui è possibile eseguire SSH sull'istanza, utilizzare l'impostazione predefinita per rendere SSH
aperto a Internet
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "AWS CloudFormation Sample Template EC2InstanceWithSecurityGroupSample:

Create an Amazon EC2 instance running the Amazon Linux AMI. This example creates an EC2
security group for the instance to give you SSH access. ",
"Parameters" : {
"KeyName": {
"Description" : "Name of an existing EC2 KeyPair to enable SSH access to the instance",
"Type": "AWS::EC2::KeyPair::KeyName",
"ConstraintDescription" : "must be the name of an existing EC2 KeyPair."
},
"SSHLocation" : {
"Description" : "The IP address range that can be used to SSH to the EC2 instances",
"Type": "String",
"MinLength": "9",
"MaxLength": "18",
"Default": "0.0.0.0/0",
"AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
"ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
}
},
"Resources" : {
"EC2Instance" : {
"Type" : "AWS::EC2::Instance",
"Properties" : {
"InstanceType" : “t2.micro”,
"SecurityGroups" : [ { "Ref" : "InstanceSecurityGroup" } ],
"KeyName" : { "Ref" : "KeyName" },
"ImageId" : “ami-6869aa05”
}
},
"InstanceSecurityGroup" : {
"Type" : "AWS::EC2::SecurityGroup",
"Properties" : {
"GroupDescription" : "Enable SSH access via port 22",
"SecurityGroupIngress" : [ {
"IpProtocol" : "tcp",
"FromPort" : "22",
"ToPort" : "22",
"CidrIp" : { "Ref" : "SSHLocation"}
} ]
}
}
},
"Outputs" : {
"InstanceId" : {
"Description" : "InstanceId of the newly created EC2 instance",
"Value" : { "Ref" : "EC2Instance" }
},
"AZ" : {
"Description" : "Availability Zone of the newly created EC2 instance",
"Value" : { "Fn::GetAtt" : [ "EC2Instance", "AvailabilityZone" ] }
},
"PublicDNS" : {
"Description" : "Public DNSName of the newly created EC2 instance",
"Value" : { "Fn::GetAtt" : [ "EC2Instance", "PublicDnsName" ] }
},
"PublicIP" : {
"Description" : "Public IP address of the newly created EC2 instance",
"Value" : { "Fn::GetAtt" : [ "EC2Instance", "PublicIp" ] }
}
}
}
AWS CloudFormer in VPC
Il modello CloudFormer converte le entità AWS esistenti in un nuovo modello CloudFormation per
accelerare il tempo di ricreare l'ambiente. CloudFormer viene avviato in un VPC predefinito che
potrebbe non essere adatto nei casi in cui il VPC predefinito viene eliminato. Questo codice base
è fork del CloudFormer originale che verrebbe lanciato all'interno di un nuovo VPC.
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "A custom CloudFormer template forked from AWS provided to extend the
capability to provide the ability to specify the VPC. Creates a Separate Stand-Alone VPC,
Subnet - 10.0.0.0/16 to launch the CloudFormer Instance. AWS CloudFormer Beta - template
creation prototype application. This tool allows you to create an AWS CloudFormation template
from the AWS resources in your AWS account. **Warning** This template creates a single EC2
instance in your account to run the application - you will be billed for the instance at
normal AWS EC2 rates.",
"Parameters" : {
"Username" : {
"Description" : "Username to log in to CloudFormer",
"Type" : "String"
},
"Password" : {
"Description" : "Password to log in to CloudFormer",
"Type" : "String",
"NoEcho" : "true"
},
"CommonNameTag" : {
"Description" : "Common Identifier / Friendly Name for the Stack",
"Type" : "String",
"Default" : "CloudFormer - Non Default VPC"
}
},
"Mappings" : {
"NetworkValues" : {
"VPC" : {"CIDR" : "10.0.0.0/16"},
"Subnet" : {"CIDR" : "10.0.10.0/16"}
},
"Region2Examples" : {
"us-east-1" : { "Examples" : "https://s3.amazonaws.com/cloudformation-examples-us-
east-1" },
"us-west-2" : { "Examples" : "https://s3-us-west-2.amazonaws.com/cloudformation-
examples-us-west-2" },
"us-west-1" : { "Examples" : "https://s3-us-west-1.amazonaws.com/cloudformation-
examples-us-west-1" },
"eu-west-1" : { "Examples" : "https://s3-eu-west-1.amazonaws.com/cloudformation-
examples-eu-west-1" },
"eu-central-1" : { "Examples" : "https://s3-eu-central-1.amazonaws.com/cloudformation-
examples-eu-central-1" },
"ap-southeast-1" : { "Examples" : "https://s3-ap-southeast-
1.amazonaws.com/cloudformation-examples-ap-southeast-1" },
"ap-northeast-1" : { "Examples" : "https://s3-ap-northeast-
1.amazonaws.com/cloudformation-examples-ap-northeast-1" },
"ap-southeast-2" : { "Examples" : "https://s3-ap-southeast-
2.amazonaws.com/cloudformation-examples-ap-southeast-2" },
"ap-northeast-2" : { "Examples" : "https://s3-ap-northeast-
2.amazonaws.com/cloudformation-examples-ap-northeast-2" },
"sa-east-1" : { "Examples" : "https://s3-sa-east-1.amazonaws.com/cloudformation-
examples-sa-east-1" },
"cn-north-1" : { "Examples" : "https://s3.cn-north-
1.amazonaws.com.cn/cloudformation-examples-cn-north-1" }
},
"Region2Principal" : {
"us-east-1" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"opsworks.amazonaws.com" },
"us-west-2" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"us-west-1" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"eu-west-1" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"ap-southeast-1" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"ap-northeast-1" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"ap-southeast-2" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"ap-northeast-2" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"sa-east-1" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"cn-north-1" : { "EC2Principal" : "ec2.amazonaws.com.cn", "OpsWorksPrincipal" :
"opsworks.amazonaws.com.cn" },
"eu-central-1" : { "EC2Principal" : "ec2.amazonaws.com", "OpsWorksPrincipal" :
"opsworks.amazonaws.com" }
},
"AWSInstanceType2Arch" : {
"t1.micro" : { "Arch" : "PV64" },
"t2.nano" : { "Arch" : "HVM64" },
"t2.micro" : { "Arch" : "HVM64" },
"t2.small" : { "Arch" : "HVM64" },
"t2.medium" : { "Arch" : "HVM64" },
"t2.large" : { "Arch" : "HVM64" },
"m1.small" : { "Arch" : "PV64" },
"m1.medium" : { "Arch" : "PV64" },
"m1.large" : { "Arch" : "PV64" },
"m1.xlarge" : { "Arch" : "PV64" },
"m2.xlarge" : { "Arch" : "PV64" },
"m2.2xlarge" : { "Arch" : "PV64" },
"m2.4xlarge" : { "Arch" : "PV64" },
"m3.medium" : { "Arch" : "HVM64" },
"m3.large" : { "Arch" : "HVM64" },
"m3.xlarge" : { "Arch" : "HVM64" },
"m3.2xlarge" : { "Arch" : "HVM64" },
"m4.large" : { "Arch" : "HVM64" },
"m4.xlarge" : { "Arch" : "HVM64" },
"m4.2xlarge" : { "Arch" : "HVM64" },
"m4.4xlarge" : { "Arch" : "HVM64" },
"m4.10xlarge" : { "Arch" : "HVM64" },
"c1.medium" : { "Arch" : "PV64" },
"c1.xlarge" : { "Arch" : "PV64" },
"c3.large" : { "Arch" : "HVM64" },
"c3.xlarge" : { "Arch" : "HVM64" },
"c3.2xlarge" : { "Arch" : "HVM64" },
"c3.4xlarge" : { "Arch" : "HVM64" },
"c3.8xlarge" : { "Arch" : "HVM64" },
"c4.large" : { "Arch" : "HVM64" },
"c4.xlarge" : { "Arch" : "HVM64" },
"c4.2xlarge" : { "Arch" : "HVM64" },
"c4.4xlarge" : { "Arch" : "HVM64" },
"c4.8xlarge" : { "Arch" : "HVM64" },
"g2.2xlarge" : { "Arch" : "HVMG2" },
"g2.8xlarge" : { "Arch" : "HVMG2" },
"r3.large" : { "Arch" : "HVM64" },
"r3.xlarge" : { "Arch" : "HVM64" },
"r3.2xlarge" : { "Arch" : "HVM64" },
"r3.4xlarge" : { "Arch" : "HVM64" },
"r3.8xlarge" : { "Arch" : "HVM64" },
"i2.xlarge" : { "Arch" : "HVM64" },
"i2.2xlarge" : { "Arch" : "HVM64" },
"i2.4xlarge" : { "Arch" : "HVM64" },
"i2.8xlarge" : { "Arch" : "HVM64" },
"d2.xlarge" : { "Arch" : "HVM64" },
"d2.2xlarge" : { "Arch" : "HVM64" },
"d2.4xlarge" : { "Arch" : "HVM64" },
"d2.8xlarge" : { "Arch" : "HVM64" },
"hi1.4xlarge" : { "Arch" : "HVM64" },
"hs1.8xlarge" : { "Arch" : "HVM64" },
"cr1.8xlarge" : { "Arch" : "HVM64" },
"cc2.8xlarge" : { "Arch" : "HVM64" }
},
"AWSInstanceType2NATArch" : {
"t1.micro" : { "Arch" : "NATPV64" },
"t2.nano" : { "Arch" : "NATHVM64" },
"t2.micro" : { "Arch" : "NATHVM64" },
"t2.small" : { "Arch" : "NATHVM64" },
"t2.medium" : { "Arch" : "NATHVM64" },
"t2.large" : { "Arch" : "NATHVM64" },
"m1.small" : { "Arch" : "NATPV64" },
"m1.medium" : { "Arch" : "NATPV64" },
"m1.large" : { "Arch" : "NATPV64" },
"m1.xlarge" : { "Arch" : "NATPV64" },
"m2.xlarge" : { "Arch" : "NATPV64" },
"m2.2xlarge" : { "Arch" : "NATPV64" },
"m2.4xlarge" : { "Arch" : "NATPV64" },
"m3.medium" : { "Arch" : "NATHVM64" },
"m3.large" : { "Arch" : "NATHVM64" },
"m3.xlarge" : { "Arch" : "NATHVM64" },
"m3.2xlarge" : { "Arch" : "NATHVM64" },
"m4.large" : { "Arch" : "NATHVM64" },
"m4.xlarge" : { "Arch" : "NATHVM64" },
"c1.medium" : { "Arch" : "NATPV64" },
"c1.xlarge" : { "Arch" : "NATPV64" },
"c3.large" : { "Arch" : "NATHVM64" },
"c3.xlarge" : { "Arch" : "NATHVM64" },
"c3.2xlarge" : { "Arch" : "NATHVM64" },
"c4.large" : { "Arch" : "NATHVM64" },
"c4.xlarge" : { "Arch" : "NATHVM64" },
"g2.2xlarge" : { "Arch" : "NATHVMG2" },
"g2.8xlarge" : { "Arch" : "NATHVMG2" },
"r3.large" : { "Arch" : "NATHVM64" },
"r3.xlarge" : { "Arch" : "NATHVM64" },
"r3.2xlarge" : { "Arch" : "NATHVM64" },
"i2.xlarge" : { "Arch" : "NATHVM64" },
"i2.2xlarge" : { "Arch" : "NATHVM64" },
"d2.xlarge" : { "Arch" : "NATHVM64" },
"d2.2xlarge" : { "Arch" : "NATHVM64" },
"hi1.4xlarge" : { "Arch" : "NATHVM64" },
"hs1.8xlarge" : { "Arch" : "NATHVM64" },
"cr1.8xlarge" : { "Arch" : "NATHVM64" },
"cc2.8xlarge" : { "Arch" : "NATHVM64" }
},
"AWSRegionArch2AMI" : {
"us-east-1" : {"PV64" : "ami-d4f7ddbe", "HVM64" : "ami-2df5df47", "HVMG2" : "ami-
95f7c0ff"},
"us-west-2" : {"PV64" : "ami-a9ae4ec9", "HVM64" : "ami-42b15122", "HVMG2" : "ami-
83a744e3"},
"us-west-1" : {"PV64" : "ami-14f68074", "HVM64" : "ami-f7f58397", "HVMG2" : "ami-
ee62138e"},
"eu-west-1" : {"PV64" : "ami-a93484da", "HVM64" : "ami-3c38884f", "HVMG2" : "ami-
25d76556"},
"eu-central-1" : {"PV64" : "ami-e8233884", "HVM64" : "ami-d8203bb4", "HVMG2" : "ami-
8fadb6e3"},
"ap-northeast-1" : {"PV64" : "ami-c8aca8a6", "HVM64" : "ami-eeabaf80", "HVMG2" : "ami-
71e6e01f"},
"ap-northeast-2" : {"PV64" : "NOT_SUPPORTED", "HVM64" : "ami-431fd12d", "HVMG2" :
"NOT_SUPPORTED"},
"ap-southeast-1" : {"PV64" : "ami-6702cc04", "HVM64" : "ami-8504cae6", "HVMG2" : "ami-
1e7ab47d"},
"ap-southeast-2" : {"PV64" : "ami-4f04232c", "HVM64" : "ami-a30126c0", "HVMG2" : "ami-
68a1860b"},
"sa-east-1" : {"PV64" : "ami-daf477b6", "HVM64" : "ami-e2f4778e", "HVMG2" :
"NOT_SUPPORTED"},
"cn-north-1" : {"PV64" : "ami-0534fc68", "HVM64" : "ami-3f36fe52", "HVMG2" :
"NOT_SUPPORTED"}
}
},
"Resources" : {
"VPC" : {
"Type" : "AWS::EC2::VPC",
"Properties" : {
"CidrBlock" : { "Fn::FindInMap" : ["NetworkValues", "VPC", "CIDR"] },
"EnableDnsHostnames" : "true",
"Tags" : [
{"Key": "Name", "Value": {"Ref":"CommonNameTag"} }
]
}
},
"Subnet" : {
"Type" : "AWS::EC2::Subnet",
"Properties" : {
"VpcId" : { "Ref" : "VPC" },
"CidrBlock" : { "Fn::FindInMap" : ["NetworkValues", "Subnet", "CIDR"] },
"MapPublicIpOnLaunch" : "true",
"Tags" : [
]
}
},
"RouteTable" : {
"Type" : "AWS::EC2::RouteTable",
"Properties" : {
"VpcId" : { "Ref" : "VPC" }
}
},
"InternetGateway" : {
"Type" : "AWS::EC2::InternetGateway",
"Properties" : {
"Tags" : [
]
}
},
"InternetGatewayAttachment" : {
"Type" : "AWS::EC2::VPCGatewayAttachment",
"Properties" : {
"InternetGatewayId" : { "Ref" : "InternetGateway"},
"VpcId" : { "Ref" : "VPC"}
}
},
"Route" : {
"Type" : "AWS::EC2::Route",
"Properties" : {
"DestinationCidrBlock" : "0.0.0.0/0",
"GatewayId" : { "Ref" : "InternetGateway" },
"RouteTableId" : { "Ref" : "RouteTable" }
}
},
"SubnetRouteTableAttachment" : {
"Type" : "AWS::EC2::SubnetRouteTableAssociation",
"Properties" : {
"RouteTableId" : { "Ref" : "RouteTable" },
"SubnetId" : { "Ref" : "Subnet" }
}
},
"CFNRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Statement": [{
"Effect": "Allow",
"Principal": { "Service": { "Fn::FindInMap" : [ "Region2Principal", {"Ref" :
"AWS::Region"}, "EC2Principal"]}},
"Action": [ "sts:AssumeRole" ]
}]
},
"Path": "/"
}
},
"CFNRolePolicy": {
"Type": "AWS::IAM::Policy",
"Properties": {
"PolicyName": "CloudFormerPolicy",
"PolicyDocument": {
"Statement": [ {
"Effect": "Allow",
"Action" : [
"autoscaling:Describe*",
"cloudformation:Describe*",
"cloudformation:List*",
"cloudfront:List*",
"cloudFront:Get*",
"cloudtrail:Describe*",
"cloudtrail:Get*",
"cloudwatch:Describe*",
"dynamodb:List*",
"dynamodb:Describe*",
"elasticbeanstalk:Describe*",
"ec2:Describe*",
"elasticloadbalancing:Describe*",
"elasticache:Describe*",
"rds:Describe*",
"rds:List*",
"route53:List*",
"route53:Get*",
"s3:List*",
"s3:Get*",
"s3:PutObject",
"sdb:Get*",
"sdb:List*",
"sns:Get*",
"sns:List*",
"sqs:Get*",
"sqs:List*",
"opsworks:Describe*",
"redshift:Describe*",
"kinesis:Describe*",
"kinesis:List*"
],
"Resource": "*"
} ]
},
"Roles": [ { "Ref": "CFNRole" } ]
}
},
"CFNInstanceProfile": {
"Type": "AWS::IAM::InstanceProfile",
"Properties": {
"Path": "/",
"Roles": [ { "Ref": "CFNRole" } ]
}
},
"WebServer": {
"Type": "AWS::EC2::Instance",
"Metadata" : {
"AWS::CloudFormation::Init" : {
"configSets" : {
"full_install" : ["base", "cloudformer"]
},
"base" : {
"packages" : {
"yum" : {
"gcc" : [],
"gcc-c++" : [],
"make" : [],
"libxml2-devel" : [],
"libxslt-devel" : [],
"sqlite-devel" : [],
"patch" : [],
"readline" : [],
"readline-devel" : [],
"zlib" : [],
"zlib-devel" : [],
"libyaml-devel" : [],
"libffi-devel" : [],
"openssl-devel" : [],
"bzip2" : [],
"autoconf" : [],
"automake" : [],
"libtool" : [],
"bison" : [],
"ruby-devel" : []
}
}
},
"cloudformer" : {
"sources" : {
"/home/ec2-user/cloudformer" : {"Fn::Join" : ["/", [
{"Fn::FindInMap" : ["Region2Examples", {"Ref" :
"AWS::Region"}, "Examples"]},
"AWSCloudFormer041.zip" ]]}
},
"files" : {
"/home/ec2-user/setup_cloudformer" : {
"content" : { "Fn::Join" : ["", [
"#!/usr/bin/env bash\n",
"cd /home/ec2-user/cloudformer\n",
"# Setup the CloudFormer service\n",
"mkdir -p vendor/bundle\n",
"gem install --local /home/ec2-user/cloudformer/vendor/cache/rake-
10.4.2.gem\n",
"gem install --local /home/ec2-user/cloudformer/vendor/cache/bundler-
1.7.11.gem\n",
"gem install --local /home/ec2-user/cloudformer/vendor/cache/bundle-
0.0.1.gem\n",
"/usr/local/bin/bundle install --local --path /home/ec2-
user/cloudformer/vendor/bundle\n",
"/usr/local/bin/rake RAILS_ENV=production db:migrate\n",
"gem install --local /home/ec2-user/cloudformer/vendor/cache/rack-
1.6.0.gem\n",
"gem install --local /home/ec2-user/cloudformer/vendor/cache/eventmachine-
1.0.4.gem\n",
"gem install --local /home/ec2-user/cloudformer/vendor/cache/daemons-
1.1.9.gem\n",
"gem install --local /home/ec2-user/cloudformer/vendor/cache/thin-
1.6.3.gem\n",
"# Create certificate and private key for SSL\n",
"mkdir -p /home/ec2-user/cloudformer/.ssl\n",
"cd /home/ec2-user/cloudformer/.ssl\n",
"openssl genrsa -des3 -passout pass:\"" , { "Ref" : "Password" }, "\" -out
server.pass.key 1024\n",
"openssl rsa -passin pass:\"", { "Ref" : "Password" }, "\" -in
server.pass.key -out server.key\n",
"openssl req -new -key server.key -out server.csr -subj
\"/C=US/ST=Washington/L=Seattle/O=Amazon Web Services/OU=CloudFormer\"\n",
"openssl x509 -req -days 365 -in server.csr -signkey server.key -out
server.crt\n",
"rm server.pass.key server.csr\n"
]]},
"mode" : "000755",
"owner" : "root",
"group" : "root"
},
"/home/ec2-user/cloudformer/config/initializers/user.rb" : {
"content" : { "Fn::Join" : ["", [
"USER_NAME = \"", { "Ref" : "Username" }, "\"\n",
"PASSWORD = \"", { "Ref" : "Password" }, "\"\n"
]]},
"mode" : "000400",
"owner" : "root",
"group" : "root"
},
"/usr/bin/cloudformer" : {
"content" : { "Fn::Join" : ["", [
"#!/usr/bin/env bash\n",
"cd /home/ec2-user/cloudformer\n",
"/usr/local/bin/thin start -p 443 -e production -d --ssl --ssl-key-file
/home/ec2-user/cloudformer/.ssl/server.key --ssl-cert-file /home/ec2-
user/cloudformer/.ssl/server.crt\n"
]]},
"mode" : "000755",
"owner" : "root",
"group" : "root"
}
},
"commands" : {
"01_install_cloudformer" : {
"command" : "/home/ec2-user/setup_cloudformer &>
/var/log/setup_cloudformer.log",
"cwd" : "/home/ec2-user/cloudformer"
},
"02_setup_boot" : {
"command" : "echo '/usr/bin/cloudformer' >> /etc/rc.local",
"cwd" : "/"
}
}
}
}
},
"Properties": {
"ImageId" : { "Fn::FindInMap" : [ "AWSRegionArch2AMI", { "Ref" : "AWS::Region" },
{ "Fn::FindInMap" : [ "AWSInstanceType2Arch", "t2.medium", "Arch" ]
} ] },
"InstanceType" : "t2.medium",
"SecurityGroupIds" : [ {"Ref" : "WebServerSecurityGroup"} ],
"SubnetId" : { "Ref" : "Subnet" },
"IamInstanceProfile" : { "Ref" : "CFNInstanceProfile" },
"UserData" : { "Fn::Base64" : { "Fn::Join" : ["", [
"#!/bin/bash -xe\n",
"yum update -y aws-cfn-bootstrap\n",
"/opt/aws/bin/cfn-init -v ",
" --stack ", { "Ref" : "AWS::StackId" },
" --resource WebServer ",
" --configsets full_install ",
" --region ", { "Ref" : "AWS::Region" }, "\n",
"/opt/aws/bin/cfn-signal -e $? ",
" --stack ", { "Ref" : "AWS::StackId" },
" --resource WebServer ",
" --region ", { "Ref" : "AWS::Region" }, "\n"
]]}}
},
"CreationPolicy" : {
"ResourceSignal" : {
"Timeout" : "PT30M"
}
}
},
"WebServerSecurityGroup" : {
"Type" : "AWS::EC2::SecurityGroup",
"Properties" : {
"GroupDescription" : "Enable HTTPS access via port 443",
"VpcId" : { "Ref" : "VPC" },
"SecurityGroupIngress" : [
{"IpProtocol" : "tcp", "FromPort" : "443", "ToPort" : "443", "CidrIp" : "0.0.0.0/0"}
]
}
}
},
"Outputs" : {
"WebsiteURL" : {
"Value" : { "Fn::Join" : ["", ["https://", { "Fn::GetAtt" : [ "WebServer",
"PublicDnsName" ]} ]] },
"Description" : "URL for CloudFormer"
}
}
}
Leggi AWS CloudFormation online: https://riptutorial.com/it/amazon-web-services/topic/6988/aws-

cloudformation
Capitolo 5: AWS Lambda
introduzione
AWS Lambda è un servizio che consente di eseguire il codice back-end senza la necessità di
eseguire il provisioning o la gestione dei server. AWS Lambda si occupa di ridimensionamento e
alta disponibilità. Il costo dipende direttamente dalla frequenza con cui viene eseguito il codice.
Troverai esempi su come creare e distribuire le funzioni di AWS Lambda in diverse lingue.
Osservazioni
• Il codice AWS Lambda deve essere scritto in modo apolide. Mentre l'istanza di un lambda
potrebbe essere mantenuta e riutilizzata, non devi mai aspettarti questo.
Examples
Progetto Basic Gradle Java
Per distribuire il codice Java in AWS Lambda, è necessario creare un file zip di distribuzione che
contenga tutte le dipendenze necessarie durante il runtime. Progetto di esempio in Gradle:
apply plugin: 'java'
repositories {
mavenCentral()
}
dependencies {
compile 'com.amazonaws:aws-lambda-java-core:1.1.0'
}
task buildZip(type: Zip) {

from compileJava
from processResources
into('lib') {
from configurations.runtime
}
}
build.dependsOn buildZip
L'esecuzione di gradle build creerà un file zip con tutte le dipendenze in bundle con il codice,
pronto per la distribuzione.
Codice Lambda di base in Java
Un lambda ha bisogno di un gestore, che fungerà da punto di ingresso per la tua applicazione.
Ogni gestore deve implementare l'interfaccia RequestHandler<I, O> dove I è il tipo di input e O è il
tipo di output. Il tipo di input viene quindi passato al metodo handleRequest() e il metodo restituisce
il tipo di output.
Un semplice esempio potrebbe assomigliare a questo:
package com.example.lambda;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class HelloNumber implements RequestHandler<Integer, String> {
@Override
public String handleRequest(Integer input, Context context) {
return "You sent " + input;
}
}
Codice Lambda di base in JavaScript (NodeJs)
Un lambda ha bisogno di un gestore, che fungerà da punto di ingresso per la tua applicazione. Nel
caso più semplice, ottieni il tuo input dal context e passa il risultato usando la funzione callback() :
exports.handler = (event, context, callback) => {callback (null, 'You ha inviato' + event.number); };
Creazione di AWS Lambda tramite la GUI Web (Java)
Per creare un lambda Java utilizzando la GUI, assicurati innanzitutto di avere la tua zip di
distribuzione pronta. Avrai anche bisogno di un account AWS in grado di creare lambda.
• Passare a AWS Lambda, chiudere la schermata di introduzione (o leggere la

documentazione di avvio) e premere il pulsante Create a Lambda Function .
• Seleziona un progetto appropriato. Un modello è un modello di esempio che può aiutarti a
creare il tuo lambda. Per ora, inizia con una Blank Function .
• Per ora, non preoccuparti dei trigger e salta quella schermata.
• Assegna un nome alla funzione e carica il file zip.
• Nella stessa schermata di configurazione, digitare il nome del gestore come classe Java
completa con il pacchetto, opzionalmente con il metodo che gestirà le richieste. Se hai
utilizzato l'interfaccia Java dall'esempio del codice Lambda di base, il nome della classe è
sufficiente.
• Nella stessa schermata, seleziona Create a new role from template(s) e assegna un nome al
ruolo. Il ruolo viene utilizzato per consentire a lambda l'accesso ad altre risorse AWS. In
questo caso, lascia vuoto perché non abbiamo bisogno di altre risorse.
• Seleziona la memoria disponibile più bassa (128 MB). Anche il costo della memoria è
costato. Salva la tua funzione.
Test del codice Lambda di base
Se è stato distribuito correttamente il Lambda, è anche possibile testarlo direttamente nella GUI.
Quando fai clic sul pulsante blu Test per la prima volta, ti viene presentata una creazione di un
nuovo evento di prova.
Se stai testando il codice Java dal codice Lambda di base nell'esempio Java , elimina tutto il corpo
e aggiungi semplicemente un numero 1 .
Se stai testando il codice Javascript dal codice Lambda di base nell'esempio di Javascript (Nodo) ,
crea un json simile al seguente:
{
"number": "1"
}
Esegui il test. Dovresti vedere il risultato:
"Hai inviato 1"
Aggiunta del trigger del gateway API AWS
Probabilmente il modo più comune per invocare un Lambda è utilizzare API Gateway, che mappa
una chiamata REST al codice lambda. Puoi aggiungere più trigger al tuo Lambda durante
qualsiasi momento, anche quando crei un nuovo lambda.
Se si ha familiarità con API Gateway, è possibile associare qualsiasi metodo a lambda distribuito.
Basta creare un nuovo metodo con il tipo di integrazione impostato sulla funzione Lambda e
puntare al lambda. È possibile associare entrambi gli ingressi REST agli ingressi lambda e alle
uscite REST.
TODO: Decidere se descrivere Gateway API qui o fare riferimento a un'altra parte della
documentazione.
Leggi AWS Lambda online: https://riptutorial.com/it/amazon-web-services/topic/8918/aws-lambda
Capitolo 6: Beanstalk elastico
Osservazioni
Limitazioni correnti (dal 2016-10-03)
• I tag di ambiente non possono essere modificati una volta creato l' ambiente , quindi scegli
saggiamente.
• La scalabilità automatica in Elastic Beanstalk è limitata a Semplice e Pianificata , quindi se si
desidera utilizzare Scalabilità scalare , considerare nuovamente se Elastic Beanstalk è una
buona soluzione.
Automazione con Jenkins
Esiste un ottimo plug-in di distribuzione AWSEB per Jenkins che verrà plug-n-play per la
distribuzione su Elastic Beanstalk (le distribuzioni blu / verdi con terminazione inattiva automatica
sono solo una casella di controllo).
Examples
Introduzione al fagiolo magico elastico
Elastic Beanstalk (EB) è essenzialmente un ibrido tra Golden AMI e CloudFormation , mentre
semplifica enormemente la curva di apprendimento di Puppet o Chef .
Una distribuzione Elastic Beanstalk è suddivisa in due componenti: Applicazione e Ambiente.
Applicazione
Considera questo il tuo raggruppamento di alto livello, la tua stessa applicazione. Ad esempio,
una singola applicazione ("MyWebApp") può avere più ambienti ("Produzione" e "Staging").
Ambiente
Ogni ambiente consisterà in una distribuzione completa dell'architettura ( istanze EC2 ,

bilanciamento del carico elastico , gruppo di scalabilità automatica e allarmi di Cloudwatch ).
L'intera configurazione dell'ambiente è impostata e gestita automaticamente.
Distribuzione di un'applicazione
La distribuzione dell'applicazione è semplice come caricare un file zip contenente il codice. Ogni
file zip (chiamato Application Version ) che carichi è associato ad un'applicazione , quindi puoi
caricarlo una volta e distribuirlo in più ambienti .
Personalizzazione dell'ambiente
Per impostazione predefinita, Elastic Beanstalk distribuirà AMI "stock" Amazon-Maintained. Per la
maggior parte delle applicazioni, questo è sufficiente, ma potrebbero essere apportate modifiche
ambientali (ad esempio, modifica del fuso orario, aggiunta di pacchetti / dipendenze non presenti
nel codice, ecc.).
Esistono due modi per personalizzare EB AMI che viene utilizzato: ebextensions o un AMI
personalizzato.
ebextensions - Una cartella, letteralmente chiamata '.ebextensions', che può essere

facoltativamente posizionata nella root della tua versione dell'applicazione (il file zip che hai
caricato contenente il tuo codice). All'interno della cartella ebextensions, è possibile inserire file
YAML che definiscono script personalizzati, dipendenze, ecc. Che si desidera eseguire sul lato
server durante il processo di distribuzione. Sono disponibili numerosi punti di aggancio, per le
informazioni più recenti, consultare la relativa documentazione:
http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/ebextensions.html
Gotchas / Cose da prendere in considerazione
Casella di controllo VPC : quando si crea un ambiente, l'opzione viene discretamente resa
disponibile per stabilire se l'ambiente debba essere creato / inserito all'interno di un VPC. Se hai
bisogno della tua applicazione per comunicare con le risorse esistenti che hai creato,
CONTROLLA QUESTA CASELLA. In caso contrario, Elastic Beanstalk creerà un nuovo gruppo di
sicurezza che è isolato dal resto del tuo VPC. Mentre sarai in grado di regolare manualmente le
impostazioni del gruppo di sicurezza dopo la creazione, provare essenzialmente ad "aggiungerlo"
a un VPC causerà una serie di problemi in seguito.
RDS : quando si crea un ambiente, è possibile creare un'istanza RDS come parte dell'ambiente.
Non è consigliabile utilizzarlo, poiché ogni volta che è necessario "ricostruire" l'ambiente (ad es.
Distribuzioni blu / verdi, risoluzione dei problemi) distruggerà e ricrea l'istanza RDS (insieme a tutti
i dati).
Distribuzioni blu / verdi su fagiolo magico
La distribuzione blu / verde è una tecnica di rilascio che riduce i tempi di inattività e il rischio
eseguendo due ambienti di produzione identici (uno chiamato "Blu", l'altro chiamato "Verde"). In
qualsiasi momento, solo uno degli ambienti serve traffico in tempo reale, mentre l'altro è inattivo.
Quando si distribuisce una nuova versione, il codice viene distribuito nell'ambiente inattivo (ad
esempio Verde) e dopo aver confermato una distribuzione corretta, viene attivato il traffico in
tempo reale (ad esempio, Green ha un nuovo codice, il traffico da Blue viene ora indirizzato a
Green). La prossima distribuzione del codice avverrà nel nuovo ambiente inattivo (seguendo
l'esempio, che ora sarebbe blu).
Esempio / Visual Aid :
fonte immagine: https://cloudnative.io/statics/blog/aws-blue-green-deployment.png
Quando si utilizza Elastic Beanstalk (EB), è possibile creare facilmente più ambienti che sono
cloni esatti l'uno dell'altro per la distribuzione del codice. Dopo aver verificato che il nuovo
ambiente è pronto per l'uso, è semplice come utilizzare la funzione "Scambia URL" in EB per
scambiare gli ambienti.
Istruzioni dettagliate: http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-

features.CNAMESwap.html
Leggi Beanstalk elastico online: https://riptutorial.com/it/amazon-web-

services/topic/7207/beanstalk-elastico
Capitolo 7: Classe di root
Examples
La classe radice di Amazon API è la seguente.
public class AmazonRootobject

{
public Itemsearchresponse ItemSearchResponse { get; set; }
}
public class Itemsearchresponse

{
public string xmlns { get; set; }
public Operationrequest OperationRequest { get; set; }
public Items Items { get; set; }
}
public class Operationrequest

{
public Httpheaders HTTPHeaders { get; set; }
public string RequestId { get; set; }
public Arguments Arguments { get; set; }
public string RequestProcessingTime { get; set; }
}
public class Httpheaders

{
public Header Header { get; set; }
}
public class Header

{
public string Name { get; set; }
public string Value { get; set; }
}
public class Arguments

{
public Argument[] Argument { get; set; }
}
public class Argument

{
public object Value { get; set; }
}
public class Items

{
public Request Request { get; set; }
public string TotalResults { get; set; }
public string TotalPages { get; set; }
public string MoreSearchResultsUrl { get; set; }
public Item[] Item { get; set; }
}
public class Request
{
public string IsValid { get; set; }
public Itemsearchrequest ItemSearchRequest { get; set; }
}
public class Itemsearchrequest

{
public string Keywords { get; set; }
public string[] ResponseGroup { get; set; }
public string SearchIndex { get; set; }
public string Sort { get; set; }
}
public class Item

{
public string ASIN { get; set; }
public string ParentASIN { get; set; }
public string DetailPageURL { get; set; }
public Itemlinks ItemLinks { get; set; }
public Smallimage SmallImage { get; set; }
public Mediumimage MediumImage { get; set; }
public Largeimage LargeImage { get; set; }
public Imagesets ImageSets { get; set; }
public Itemattributes ItemAttributes { get; set; }
public OfferSummary OfferSummary { get; set; }
public Offers Offers { get; set; }
public Variationsummary VariationSummary { get; set; }

}
public class Variationsummary

{
public Highestprice HighestPrice { get; set; }
public Lowestprice LowestPrice { get; set; }
public Highestsaleprice HighestSalePrice { get; set; }
public Lowestsaleprice LowestSalePrice { get; set; }
}
public class Highestprice

{
public string Amount { get; set; }
public string CurrencyCode { get; set; }
public string FormattedPrice { get; set; }
}
public class Lowestprice

{
}
public class Highestsaleprice

{
}
public class Lowestsaleprice
{
}
public class Itemlinks

{
public Itemlink[] ItemLink { get; set; }
}
public class Itemlink

{
public string Description { get; set; }
public string URL { get; set; }
}
public class Smallimage

{
public Height Height { get; set; }
public Width Width { get; set; }
}
public class Height

{
public string Units { get; set; }
public string text { get; set; }
}
public class Width

{
}
public class Mediumimage

{
public Height1 Height { get; set; }
public Width1 Width { get; set; }
}
public class Height1

{
}
public class Width1

{
}
public class Largeimage

{
public Height2 Height { get; set; }
public Width2 Width { get; set; }
}
public class Height2
{
}
public class Width2

{
}
public class Imagesets

{
public object ImageSet { get; set; }
}
public class Itemattributes

{
public string Binding { get; set; }
public string Brand { get; set; }
public string Color { get; set; }
public string Model { get; set; }
public string Manufacturer { get; set; }
public string ProductGroup { get; set; }
public string Title { get; set; }
public ListPrice ListPrice { get; set; }
}
public class ListPrice

{
}
public class OfferSummary

{
public Lowestnewprice LowestNewPrice { get; set; }
public Lowestusedprice LowestUsedPrice { get; set; }
public string TotalNew { get; set; }
public string TotalUsed { get; set; }
public string TotalCollectible { get; set; }
public string TotalRefurbished { get; set; }
public Lowestrefurbishedprice LowestRefurbishedPrice { get; set; }
}
public class Lowestnewprice

{
}
public class Lowestusedprice

{
}
public class Lowestrefurbishedprice
{
}
public class Offers

{
public string TotalOffers { get; set; }
public string TotalOfferPages { get; set; }
public string MoreOffersUrl { get; set; }
public Offer Offer { get; set; }
}
public class Offer

{
public Merchant Merchant { get; set; }
public Offerattributes OfferAttributes { get; set; }
public Offerlisting OfferListing { get; set; }
}
public class Merchant

{
}
public class Offerattributes

{
public string Condition { get; set; }
}
public class Offerlisting

{
public string OfferListingId { get; set; }
public string PricePerUnit { get; set; }
public Price Price { get; set; }
public string Availability { get; set; }
public Availabilityattributes AvailabilityAttributes { get; set; }
public string IsEligibleForSuperSaverShipping { get; set; }
public string IsEligibleForPrime { get; set; }
public Saleprice SalePrice { get; set; }
public Amountsaved AmountSaved { get; set; }
public string PercentageSaved { get; set; }
}
public class Price

{
}
public class Availabilityattributes

{
public string AvailabilityType { get; set; }
public string MinimumHours { get; set; }
public string MaximumHours { get; set; }
}
public class Saleprice
{
}
public class Amountsaved

{
}
Business class
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using ApplicationDataServices.SBEntityBox;
namespace ApplicationManagementLayer.Affiliate
{
public class Amazon
{
private int ItemPage { get; set; }
public int TotalNumberOfItem { get; set; }
public Amazon()
{
ItemPage = 1;
TotalNumberOfItem = 0;
}
string XMLURL = string.Empty;
public async Task<AmazonRootobject> getProductsByKeywords(string q, Dictionary<string,

string> CategoryNames, int ItemPage, string categorynamebyid)
{
try
{
AWSSignedRequestHelper helper = new AWSSignedRequestHelper("para1", "para2",
"webservices.amazon.in", "para3");
IDictionary<string, string> r1 = new Dictionary<string, String>();
r1["Service"] = "AWSECommerceService";
r1["Operation"] = "ItemSearch";
if (CategoryNames != null && CategoryNames.Any() && CategoryNames.Where(o =>

o.Key.Equals("AmazonCategoryName")).Any())
r1["SearchIndex"] = CategoryNames.Where(o =>
o.Key.Equals("AmazonCategoryName")).First().Value;
else
r1["SearchIndex"] = "All";
if (!r1["SearchIndex"].Equals("All") && CategoryNames != null && CategoryNames.Any()

&& CategoryNames.Where(o => o.Key.Equals("AmazonReferenceCategoryId")).Any())
r1["BrowseNode"] = CategoryNames.Where(o =>
o.Key.Equals("AmazonReferenceCategoryId")).First().Value;
if (!string.IsNullOrEmpty(q))
r1["Keywords"] = q;
else if (!string.IsNullOrEmpty(categorynamebyid))
r1["Keywords"] = categorynamebyid;
else if (CategoryNames != null && CategoryNames.Any() && CategoryNames.Where(o =>
o.Key.Equals("AmazonCategoryName")).Any())
r1["Keywords"] = CategoryNames.Where(o =>
o.Key.Equals("AmazonCategoryName")).First().Value;
else
return null;
r1["ResponseGroup"] = "Images,ItemAttributes,OfferFull,Offers,Variations";
r1["Version"] = "2013-08-01";
r1["ItemPage"] = ItemPage.ToString();
//r1["Sort"] = "salesrank";
string strRequestUrl = helper.Sign(r1);
string output = null;

using (System.Net.Http.HttpClient wc = new System.Net.Http.HttpClient())
{
var request = new System.Net.Http.HttpRequestMessage()
{
RequestUri = new Uri(strRequestUrl),
Method = System.Net.Http.HttpMethod.Get,
};
/*var task =*/

await wc.SendAsync(request)
.ContinueWith((taskwithmsg) =>
{
var response = taskwithmsg.Result;
var jsonTask = response.Content.ReadAsStringAsync();

jsonTask.Wait();
output = jsonTask.Result;
});
//task.Wait();
XmlDocument doc = new XmlDocument();

doc.LoadXml(output);
string outputJson = XmlToJSON(doc);
var pro = new

System.Web.Script.Serialization.JavaScriptSerializer().Deserialize<AmazonRootobject>(outputJson);
TotalNumberOfItem = !string.IsNullOrEmpty(pro.ItemSearchResponse.Items.TotalResults) ?
Convert.ToInt32(pro.ItemSearchResponse.Items.TotalResults) : 0;
return pro;
//return "";
}
catch
{
return null;
}
}
http://stackoverflow.com/documentation/amazon-web-services/drafts/87373#
}
}
Leggi Classe di root online: https://riptutorial.com/it/amazon-web-services/topic/7357/classe-di-root
Capitolo 8: Distribuire un'immagine del
contenitore finestra mobile utilizzando ECS
Osservazioni
Prima di poter aggiungere istanze ECS a un cluster, è necessario innanzitutto
AmazonEC2ContainerServiceforEC2Role alla console di gestione EC2 e creare istanze ecs-optimized
con un ruolo IAM con allegato il criterio AmazonEC2ContainerServiceforEC2Role .
1. Vai al tuo EC2 Dashboard e fai clic sul pulsante Launch Instance .
2. Sotto Community AMIs , cerca ecs-optimized e seleziona quello che meglio si adatta alle tue
esigenze di progetto. Qualsiasi funzionerà. Clicca dopo.
3. Quando si arriva a Configure Instance Details , fare clic sul create new IAM role link e creare
un nuovo ruolo chiamato ecsInstanceRole .
4. Allegare la politica AmazonEC2ContainerServiceforEC2Role a quel ruolo.
5. Per impostazione predefinita, l'istanza del contenitore viene avviata nel cluster default . Se si
desidera eseguire l'avvio nel proprio cluster anziché nell'impostazione predefinita,
selezionare l'elenco Advanced Details e incollare lo script seguente nel campo User data ,
sostituendo your_cluster_name con il nome del cluster.
#!/bin/bash
echo ECS_CLUSTER=your_cluster_name >> /etc/ecs/ecs.config
6. Quindi, completa la configurazione della tua istanza ECS.
NOTA: se si crea un server Web, si vorrà creare un securityGroup per consentire l'accesso alla
porta 80.
7. Creare un repository: aws ecr create-repository --repository-name example-repository

8. Autentica il tuo client Docker nel tuo registro: aws ecr get-login --region us-east-1 | sh
9. Costruisci la tua immagine Docker: docker build -t example-image .
10. Tagga la tua immagine in modo che tu possa spingere l'immagine su questo repository:
docker tag example-image:latest example-namespace/example-image:latest
11. Spingi questa immagine al tuo repository AWS appena creato: docker push example-
namespace/example-image:latest
12. Registrare una definizione di attività ECS: aws ecs register-task-definition --cli-input-json
example-task.json
13. Esegui l'attività: aws ecs run-task --task-definition example-task
Examples
esempio-task.json
{
"family": "example-task",
"containerDefinitions": [
{
"environment": [],
"name": "example-container",
"image": "example-namespace/example-image:latest",
"cpu": 10,
"memory": 500,
"portMappings": [
{
"containerPort": 8080,
"hostPort": 80
}
],
"entryPoint": [],
"essential": true
}
]
}
Distribuire un'applicazione di esempio sul servizio AWS ECS come prova del
concetto
Segui le seguenti fasi per provare un'applicazione di

esempio sul servizio AWS ECS come prova del concetto.
1. Accedi alla console di gestione AWS e vai al catalogo dei servizi AWS -> Calcola -> Ec2
2. Crea una VM (istanza EC2) usando il sistema operativo Amazon Linux 64 bit, che useremo
per configurare la finestra mobile, git, lo strumento dell'agente ECS AWS e altri strumenti.
Useremo anche la stessa VM di un nodo nel cluster ECS per distribuire applicazioni basate
su container. Seguire i seguenti passaggi per creare una VM.
a) Seguire le normali procedure per creare un'istanza EC2, dare un accento speciale sui
passaggi successivi durante la creazione dell'istanza EC2.
b) Selezionare un ruolo IAM con le seguenti autorizzazioni minime:
AmazonEC2ContainerServiceforEC2Role
c) Assicurarsi che java sia installato sulla VM
3. Installazione della finestra mobile [eseguire i comandi sottostanti]

per prima cosa aggiorna il repository del pacchetto yum
sudo yum update –y
ora per installare docker eseguire yum install
sudo yum install -y docker
4. Avvia il servizio di finestra mobile
sudo service docker start
5. Aggiungi ec2-user al gruppo docker in modo da poter eseguire i comandi Docker senza
usare sudo.
sudo usermod -a -G docker ec2-user
6. Disconnettersi da EC2 e ricollegarsi per recuperare le nuove autorizzazioni del gruppo

finestra mobile.
7. Verificare che ec2-user possa eseguire i comandi Docker senza sudo.
docker info
8. Installare Git
sudo yum install -y git
9. Clona l'applicazione PHP di esempio sull'istanza di Ec2 da git. Useremo questa applicazione
per il nostro POC.
git clone https://github.com/awslabs/ecs-demo-php-simple-app
cd ecs-demo-php-simple-app
verificare che Dockerfile esista elencando il contenuto della directory
ls
10. Vai al catalogo dei servizi AWS -> Calcola -> Servizio contenitore Ec2
11. Clicca su Inizia
12. Clicca su Annulla
13. Fare clic su repository dal menu Repository a sinistra
14. Clicca su Inizia
15. Immettere il nome del repository e fare clic su Avanti
16. Configura gli strumenti Ec2
aws configure
fornire l'ID chiave di accesso AWS, la chiave di accesso segreto, il nome della regione predefinita
come da account
17. Costruisci, contrassegna e spinge l'immagine del Docker

a) Recupera il comando di login della finestra mobile che è possibile utilizzare per
autenticare il client Docker nel registro:
aws ecr get-login --region us-east-1
b) Esegui il comando return come output del passaggio precedente
18. Costruisci l'immagine del Docker dal tuo Dockerfile. (Richiama il passaggio 9, in cui hai
scaricato un'app mobile di esempio)
un)
docker build -t amazon-ecs-sample .
(Nota: "." Sta per directory corrente)

b) Esegui immagini di finestra mobile per verificare che l'immagine sia stata creata correttamente
e che il nome dell'immagine contenga un archivio che è possibile trasferire le modifiche
all'immagine della finestra mobile
docker images
c) Esegui l'immagine appena costruita. L'opzione -p 80:80 associa la porta esposta 80 sul
contenitore alla porta 80 sul sistema host (in questo caso l'istanza Ec2).
docker run -p 80:80 amazon-ecs-sample
Ignora l'avviso "apache2: impossibile determinare in modo affidabile il nome di dominio completo
del server, utilizzando 172.17.0.2 per ServerName"
19. Prova ad accedere alla pagina Web dell'applicazione di esempio sul browser, assicurati che
la porta 80 sia aperta nei gruppi di sicurezza associati all'istanza
http://<ec2-instance-dns-address>
20. Premere ctrl + c, questo fermerà l'immagine della finestra mobile. L'applicazione di esempio
non dovrebbe essere accessibile.
21. Ora, dopo aver verificato con successo la nostra applicazione mobile di esempio, proveremo
a configurare un cluster per eseguire automaticamente l'applicazione di esempio. Inoltre, per
lo scopo dimostrativo cercheremo di utilizzare l'istanza ec2 esistente come nodo nel cluster.
Questo può essere ottenuto installando un programma agente sull'istanza di ec2.
22. Installazione di Amazon ECS Container Agent sull'istanza di ec2
un)
sudo yum install -y ecs-init
b) Riavvia il daemon docker
sudo service docker restart
c) Avviare il lavoro upstart di ecs-init
sudo start ecs
d) (Facoltativo) È possibile verificare che l'agente sia in esecuzione e visualizzare alcune

informazioni sulla nuova istanza del contenitore con l'API di introspezione dell'agente. Assicurarsi
che la porta 51678 sia aperta nel gruppo di sicurezza.
curl http://localhost:51678/v1/metadata
23. Vai al catalogo dei servizi AWS -> Calcola -> Servizio contenitore Ec2 -> Cluster e verifica
che venga creato un cluster predefinito
24. Ora procediamo con la creazione di un gruppo di task e aggiungendo l'immagine della
finestra mobile come attività da eseguire sul cluster
a) Esaminare il file simple-app-task-def.json nella cartella ecs-demo-php-simple-app.
b) Modifica la semplice app-task-def.json e riduci la momeoria, in modo che possa essere
eseguita su istanze idonee di livello libero (presumo che si stia utilizzando un'istanza ec2
ammissibile di livello libero per questo POC, altrimenti non è necessario ridurre la memoria
limite)
c) Memoria di aggiornamento = 250 in tutte le occorrenze nel file simple-app-task-def.json
d) Registrare una definizione di attività con il file simple-app-task-def.json.
aws ecs register-task-definition --cli-input-json file://simple-app-task-def.json
e) Vai alla definizione del compito nella pagina del servizio del contenitore ec2, troverai la
definizione del compito registrato
f) Utilizzare il seguente comando CLI AWS per eseguire un'attività con la definizione dell'attività
della console-esempio-app.
aws ecs run-task --task-definition console-sample-app
g) Aprire l'app web di esempio nel browser, dovrebbe essere accessibile (fare riferimento al punto
19)
Grazie per la lettura, condividi i tuoi commenti e le tue domande per la discussione di follow-up.
Leggi Distribuire un'immagine del contenitore finestra mobile utilizzando ECS online:
https://riptutorial.com/it/amazon-web-services/topic/7711/distribuire-un-immagine-del-contenitore-
finestra-mobile-utilizzando-ecs
Titoli di coda
S.
Capitoli Contributors
No
Iniziare con Amazon

1 Community, Cyril Duchon-Doris, Karan Shah, Lynn Langit
Web Services
2 Amazon Cognito Jeet
3 Amazon DynamoDB swapnil kadu
AWS
4 Hardeep Singh, Naveen Vijay
CloudFormation
5 AWS Lambda jarmod, sm4
6 Beanstalk elastico Lorenzo Aiello
7 Classe di root vicky
Distribuire
un'immagine del
8 contenitore finestra mrded, Satish
mobile utilizzando
ECS

Tutorial - Learning Amazon-Web-Services (ITA)

Caricato da

Informazioni sul documento

Descrizione:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Descrizione:

Copyright:

Formati disponibili

Tutorial - Learning Amazon-Web-Services (ITA)

Titolo originale:

Caricato da

Descrizione:

Copyright:

Formati disponibili

amazon-web-services

Capitolo 1: Iniziare con Amazon Web Services 2

Prima che sia troppo tardi 2

Capitolo 2: Amazon Cognito 4

Gestione dell'identità utente tramite Amazon Cognito 4

Capitolo 3: Amazon DynamoDB 7

DynamoDB Basic Crud Operation usando NodeJS 7

Capitolo 4: AWS CloudFormation 8

AWS CloudFormer in VPC 9

Capitolo 5: AWS Lambda 19

Progetto Basic Gradle Java 19

Codice Lambda di base in Java 19

Codice Lambda di base in JavaScript (NodeJs) 20

Creazione di AWS Lambda tramite la GUI Web (Java) 20

Test del codice Lambda di base 20

Aggiunta del trigger del gateway API AWS 21

Capitolo 6: Beanstalk elastico 22

Introduzione al fagiolo magico elastico 22

Capitolo 7: Classe di root 25

La classe radice di Amazon API è la seguente. 25

Capitolo 8: Distribuire un'immagine del contenitore finestra mobile utilizzando ECS 33

Versione Data di rilascio

Consigli e trucchi per evitare situazioni pericolose

Istanze EC2 ed EBS

• Imposta i ruoli IAM.

• Attenzione all'integrità dell'istantanea

Leggi Iniziare con Amazon Web Services online: https://riptutorial.com/it/amazon-web-

var app = {};

AWS.config.region = 'us-east-1'; // Region

var attributeList = [];

var confirmationCode = prompt("Hello "+cognitoUser.getUsername+" Enter the confirmation code

Leggi Amazon Cognito online: https://riptutorial.com/it/amazon-web-services/topic/3425/amazon-

let doc = require('dynamodb-doc');

exports.handler = (event, context, callback) => {

Leggi Amazon DynamoDB online: https://riptutorial.com/it/amazon-web-

"Description" : "AWS CloudFormation Sample Template EC2InstanceWithSecurityGroupSample:

AWS CloudFormer in VPC

Leggi AWS CloudFormation online: https://riptutorial.com/it/amazon-web-services/topic/6988/aws-

apply plugin: 'java'

task buildZip(type: Zip) {

Codice Lambda di base in Java

Un semplice esempio potrebbe assomigliare a questo:

public class HelloNumber implements RequestHandler<Integer, String> {

Codice Lambda di base in JavaScript (NodeJs)

Creazione di AWS Lambda tramite la GUI Web (Java)

• Passare a AWS Lambda, chiudere la schermata di introduzione (o leggere la

Test del codice Lambda di base

Esegui il test. Dovresti vedere il risultato:

"Hai inviato 1"

Aggiunta del trigger del gateway API AWS

Leggi AWS Lambda online: https://riptutorial.com/it/amazon-web-services/topic/8918/aws-lambda

Automazione con Jenkins

Una distribuzione Elastic Beanstalk è suddivisa in due componenti: Applicazione e Ambiente.

Ogni ambiente consisterà in una distribuzione completa dell'architettura ( istanze EC2 ,

ebextensions - Una cartella, letteralmente chiamata '.ebextensions', che può essere

Gotchas / Cose da prendere in considerazione

Distribuzioni blu / verdi su fagiolo magico

Esempio / Visual Aid :

Istruzioni dettagliate: http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-

/var task =/