AWS üzerindeki projeler

Modern Bir Web Uygulaması Oluşturun

Bir web uygulaması dağıtın, bir veritabanına bağlanın ve kullanıcı davranışını analiz edin

Modül 2: Uygulamanızı bir Web Sunucusunda Depolayın

Bu modülde AWS Fargate kullanarak barındırılan yeni bir mikro hizmet oluşturacaksınız.  

Genel Bakış

Bu modülde, Mythical Mysfits web sitenizi uygulama arka ucuyla entegre edebilmeniz için AWS Fargate kullanarak barındırılan yeni mikro hizmet oluşturacaksınız.

AWS Fargate, herhangi bir küme veya sunucuyla uğraşmak zorunda kalmadan container’lar dağıtmanızı sağlayan Amazon Elastic Container Service’de (ECS) bulunan bir dağıtım seçeneğidir. Mythical Mysfits arka uçlarımız için bir Network Load Balancer’ın arkasında Python kullanarak Docker container’ında bir Flask uygulaması oluşturacağız. Bu, ön uç web sitesi için mikro hizmet arka ucunu oluşturacaktır.

Neden Fargate’i seçtik?

Fargate’i seçtik çünkü web, mobil ve PaaS platformları için mikro hizmet arka uçları gibi uzun süreli işlemler oluşturmak için iyi bir seçenektir. Fargate ile container’ların kontrolü ve sunucuların tedariği veya ölçeklendirilmesi hakkında kaygı duymadan çalıştıklarında seçme esnekliği elinizde olur. Hizmet iletişimi için ağ iletişimi, güvenlik ve hizmetin tam kontrolünü sunar ve güvenlik, ağ iletişimi, erişim kontrolü, geliştirici araçları, görüntüleme ve günlük kaydı için AWS hizmetleri ile yerel olarak entegredir.

Fargate’e ek olarak müşteriler işlem ihtiyaçları için AWS Lambda kullanma seçenekleri de mevcuttur. Lambda, Fargate ile aynı sunucusuz faydaları sağlasa da verilerdeki değişikliklere, sistem durumundaki değişimlere veya kullanıcıların eylemlerine gerçek zamanlı olarak yanıt vermesi gereken veri odaklı uygulamalar için mükemmeldir. Lambda’yı, Modül 5’te sitede müşteri davranışlarını incelemek için kullandığımızda daha ayrıntılı bir şekilde tartışacağız.

Uygulama Talimatları

AWS Fargate hizmetinizi oluşturmak için aşağıda adım adım gösterilen talimatları takip edin. Bu büyük bir modül olduğu için bunları 3 alt modüle ayırdık. Modül 2a’da hizmet dağıtımınızın hazırlığı olarak çekirdek altyapı kuracaksınız. Modül 2b’de AWS Fargate kullanarak hizmetinizi dağıtacaksınız. Son olarak modül 2c’de AWS Code Services kullanarak otomatik dağıtım kuracaksınız.

Modül 2A: Çekirdek Altyapıyı Kurun

Hizmetimizi oluşturabilmemiz için Amazon VPC’de ağ iletişimi alt yapısı dâhil olmak üzere hizmetin kullanacağı çekirdek altyapı ortamını ve ECS ve container’larımızın AWS üzerindeki izinlerini tanımlayacak olanAWS Identity and Access Management Roles’u oluşturmamız gerekmektedir.

AWS CloudFormation’ı bunu başarmak için kullanacağız. AWS CloudFormation, CloudFormation Şablonları olarak adlandırılan JSON veya YAML içerisinde bildirdiğiniz AWS kaynaklarını, ortak altyapı en iyi uygulamasını kod olarak etkinleştirerek programlama yoluyla tedarik edebilen bir hizmettir.  

  • /module-2/cfn/core.yml’da tüm gerekli Ağ İletişimi ve Güvenlik kaynaklarını oluşturmak için CloudFormation şablonu sağladık. Bu şablon aşağıdaki kaynakları oluşturacaktır:

    • Amazon VPC - 10.0.0.0/16 özel IP alanındaki dört alt ağı (iki ortak ve iki özel olmak üzere) içeren bir ağ iletişimi ortamı ve aynı zamanda gerekli olan Yol Tablosu yapılandırmalarını içerir. Bu ağ iletişimi için gereken alt ağlar, bir AWS Bölgesinde birden fazla fiziksel tesislerde yüksek erişilebilirliği etkinleştirmek için ayrı AWS Erişilebilirlik Alanlarında (AZ) oluşturulmaktadır. AZ’lerin yüksek erişilebilirliğe ulaşmanıza nasıl yardım edebileceği hakkında daha fazla bilgi edinin.
    • İki NAT Ağ Geçidi (her bir ortak alt ağ için birer tane olmak üzere ) - son olarak özel alt ağlarımıza dağıtacağımız container’larımızın gerekli paketleri indirmek vb. için internete bağlanmalarını sağlar.
    • Mikro hizmet arka ucumuz DynamoDB VPC Uç Noktası süreklilik için son olarak Amazon DynamoDB ile entegre olacaktır (modül 3’ün bir parçası olarak).
    • Güvenlik Grubu - Docker container’larımızın 8080 numaralı bağlantı noktasının Network Load Balancer aracılığıyla internetten trafik almasını sağlar.
    • IAM Rolleri - Identity and Access Management Rolleri oluşturuldu. Bunlar, oluşturduğunuz AWS hizmetlerinin veya kaynaklarının DynamoDB, S3 ve daha fazlası gibi AWS hizmetlerine erişim sağlamak için atölye sırasında kullanılacaktır.

    Bu kaynakları oluşturmak için aşağıdaki komutu Cloud9 terminalinde çalıştırın (yığının oluşturulması ~10 dakika sürecektir):

    aws cloudformation create-stack --stack-name MythicalMysfitsCoreStack --capabilities CAPABILITY_NAMED_IAM --template-body file://~/environment/aws-modern-application-workshop/module-2/cfn/core.yml

    Yığın oluşumunuzun durumunu AWS Console aracılığıyla veya aşağıdaki komutu çalıştırarak kontrol edebilirsiniz:

    aws cloudformation describe-stacks --stack-name MythicalMysfitsCoreStack

    describe-stacks (yığınları tanımla) komutunu "StackStatus" durumunu görene kadar çalıştırmaya devam edin: "CREATE_COMPLETE"

    yığınları tanımlayın

    (yakınlaştırmak için tıklayın)

    Bu yanıtı aldığınızda CloudFormation, yukarıda tanımlanan tüm çekirdek ağ iletişimi ve güvenlik kaynaklarını tamamlamış anlamına gelir ve siz devam edebilirsiniz. Devam etmeden önce yukarıdaki yığının CREATE_COMPLETE göstermesini bekleyin.

    Atölyenin kalanı boyunca bu komutun çıktısının değerlerini kullanacaksınız. Yukarıda tanımlanan describe-stacks komutunu, cloudformation-core-output.json olarak depolanacak IDE’nizde yeni bir dosyaya doğrudan çıkarmak için aşağıdaki komutu çalıştırabilirsiniz:

    aws cloudformation describe-stacks --stack-name MythicalMysfitsCoreStack > ~/environment/cloudformation-core-output.json

Modül 2B: AWS Fargate ile Bir Hizmet Dağıtın

Sonraki adım olarak Mythical Mysfits arka ucunu Flask ile oluşturulan bir mikro hizmet API'ı olarak çalıştırmak için gereken tüm kodları ve yapılandırmaları içeren Docker container oluşturacaksınız. Docker container görüntüsünü Cloud9 içerisinde oluşturacağız ve daha sonra Fargate kullanarak oluşturacağımız hizmetimizi oluşturduğumuzda çekmek için hazır olacak olan Amazon Elastic Container Registry’ye ileteceğiz.

Mimari Diyagramı

Fargate’e dengeleyici yükleyecek tarayıcı
  • A: Docker Görüntüsü Oluşturun

    Hizmet arka ucumuzu çalıştırmak için gereken tüm kodlar, Cloud9 IDE’nize klonladığınız /module-2/app/ depo dizini içerisinde depolanmıştır. Hizmet API’sini oluşturmak için Flask’ı kullanan Python kodunu incelemek isterseniz /module-2/app/service/mythicalMysfitsService.py dosyasını görüntüleyin.

    Docker, oluşturduğunuz Cloud9 IDE’de halihazırda yüklü bir şekilde gelir; böylece Docker görüntüsünü yerel olarak oluşturmak için ihtiyacımız olan tek şey aşağıdaki iki komutu Cloud9 terminalinde çalıştırmaktır:  

    Öncelikle dizini şununla değiştirin ~/environment/module-2/app

    cd ~/environment/aws-modern-application-workshop/module-2/app

    Hesap kimlik bilgilerinizi ve varsayılan bölgenizi önceki CloudFormation **describe-stacks’dan bulabilirsiniz

    Docker talimatlarını içeren Dockerfile dosyasını kullanarak docker görüntüsü oluşturmak için aşağıdaki komutta REPLACE_ME_ACCOUNT_ID’i hesap kimlik bilgileriniz ile ve REPLACE_ME_REGION’i varsayılan bölgeniz ile değiştirin. Komut, görüntünün daha sonra Amazon Elastic Container Registry hizmetine iletilebilmesi için Docker görüntüsünü t seçeneği kullanılarak belirli bir etiket formatı ile etiketlemektedir.

    Hesap Kimlik Bilgilerinizi aldığınızda docker görüntüsünü oluşturmaya hazır olursunuz:

    docker build . -t REPLACE_ME_AWS_ACCOUNT_ID.dkr.ecr.REPLACE_ME_REGION.amazonaws.com/mythicalmysfits/service:latest

    Docker indirme seçeneğinigördüğünüzde uygulamanız için gereken tüm bağımlılık paketlerini yükletin ve oluşturulan görüntünüz için etiketi yapıştırın. Daha sonra tekrar başvurmak için görüntü etiketini kopyalayın. Aşağıda örnek etiket gösterilmiştir: 111111111111.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest

    Successfully built 8bxxxxxxxxab
    Successfully tagged 111111111111.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest
    B: Hizmeti Yerel Olarak Test Edin

    Cloud9’da her şeyin beklendiği gibi çalıştığından emin olmak için görüntümüzü test edelim. Bir önceki komut ile ortaya çıkangörüntü etiketini kopyalayın ve container’ı yerel olarak dağıtmak için aşağıdaki komutu çalıştırın (aslında AWS içerisinde Cloud9 IDE hesabınızda bulunmaktadır!):

    docker run -p 8080:8080 REPLACE_ME_WITH_DOCKER_IMAGE_TAG

    Sonuç olarak Docker’ın, container’ınızın yüklendiğini ve yerel olarak çalıştığını raporladığını göreceksiniz:

     * Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)

    Yerel istek ile hizmetimizi test etmek için IDE bulut sunucusunda çalışan uygulamaları incelemek için kullanılabilen Cloud9 IDE’deki yerleşik web tarayıcısını açacağız.

    Ön izleme web tarayıcısını açmak için Cloud9 menü çubuğunda Ön izleme > Çalışan Uygulama Ön izlemesi öğelerini seçin:

    preview-menu

     

    Bu IDE’de, web tarayıcısının erişilebilir olduğu başka bir pano açacaktır. Ön izleme tarayıcısının adres çubuğundaURI’nin sonuna /mysfits ekleyin veENTER tuşuna basın:

    address-bar

    Başarılı olursa `/aws-modern-application-workshop/module-2/app/service/mysfits-response.json`’da depolanan JSON belgesini geri veren hizmetten bir yanıt göreceksiniz

    Hizmeti test etmeyi bitirdiğinizde bilgisayarınızda veya Mac’inizde CTRL-c’ye basarak durdurabilirsiniz.

    C: Docker görüntüsünü Amazon ECR’ye İletin

    Hizmetimizin başarılı yerel testinden sonra Amazon Elastic Container Registry’de bir container görüntü deposu oluşturmaya ve görüntümüzü ona iletmeye hazırız. Kayıt defterini oluşturmak için aşağıdaki komutu çalıştırın; böylelikle hesabınız için oluşturulan varsayılan AWS ECR kayıt defterinde yeni bir depo oluşturulur.

    aws ecr create-repository --repository-name mythicalmysfits/service

    Bu komuta verilen yanıt, oluşturulan depo hakkında ek meta veri içerecektir. Container görüntülerini yeni depomuza iletmek için depoya göndermek amacıyla Docker istemcimiz için kimlik doğrulama bilgilerini almamız gerekecektir.

    Docker istemcimiz için kimlik bilgilerini almak amacıyla bir oturum açma komutunu geri gönderecek olan ve daha sonra otomatik olarak çalıştıracak olanaşağıdaki komutu çalıştırın (aşağıdaki USD işareti dâhil olmak üzere tüm komutu dâhil edin). Komut başarılı olursa 'Oturum Açma Başarılı' bildirisi gelecektir.

    $(aws ecr get-login --no-include-email)

    Sonraki adım olarak yukarıdaki kopyalanan etiketi kullanarak oluşturduğunuz görüntüyü ECR deposuna iletin. Bu komutu kullanarak Docker görüntünüzü ve bağlı olduğu tüm görüntüleri Amazon ECR’ye iletecektir.

    docker push REPLACE_ME_WITH_DOCKER_IMAGE_TAG

    Yeni iletilmiş Docker görüntünüzün ECR deposunda depolandığını görmek için aşağıdaki komutu çalıştırın:

    aws ecr describe-images --repository-name mythicalmysfits/service
  • A: AWS Fargate Kümesi Oluşturun

    AWS Fargate kullanarak Amazon ECS’de barındırılan bir hizmete dağıtabileceğimiz ECR’de mevcut bir görüntümüz var. Son modülün bir parçası olarak Cloud9’daki terminal aracılığıyla yerel olarak test ettiğiniz aynı hizmet şimdi buluta dağıtılacak ve bir Network Load Balancer arkasında genel kullanıma sunulacaktır.

    Öncelikle Amazon Elastic Container Service (ECS)’de bir küme oluşturacağız. Bu, hizmet container’ınızın dağıtılacağı “sunucular” kümesini temsil etmektedir. Sunucular “tırnak içindeler” çünkü AWS Fargate kullanacaksınız. Fargate, container’larınızın herhangi bir sunucuyu kendiniz tedarik etmek veya yönetmek zorunda kalmadan bir kümeye dağıtılacağını belirtmenize olanak sağlar.

    ECS’de yeni bir küme oluşturmak için aşağıdaki komutu çalıştırın:

    aws ecs create-cluster --cluster-name MythicalMysfits-Cluster
    B: AWS CloudWatch Logs Grubu Oluşturun

    Sonraki adım olarak AWS CloudWatch Logs’da yeni bir günlük grubu oluşturacağız. AWS CloudWatch Logs, günlük koleksiyonu ve analizi için bir hizmettir. Container’ınızın oluşturduğu günlükler, bu belirli grubun bir parçası olarak otomatik olarak AWS CloudWatch günlüklerine iletilecektir. Bu özellikle AWS Fargate kullanırken önemlidir çünkü container’larınızın çalıştığı sunucu altyapısına erişiminiz olmayacaktır.

    Yeni günlük grubunuzu CloudWatch günlüklerinde oluşturmak için aşağıdaki komutu çalıştırın:

    aws logs create-log-group --log-group-name mythicalmysfits-logs
    C: Bir ECS Görev Tanımı Kaydedin

    Şimdi bir küme oluşturduğumuz ve container günlüklerimizin iletileceği bir günlük grubu tanımladığımıza göre ECS görev tanımı kaydetmeye hazırız. ECS’de bir görev, birlikte planlanması gereken birkaç container görüntüsüdür. Görev tanımı, birkaç container’ı ve bu container’ların gerektirdiği kaynakları ve yapılandırmaları belirtir. AWS CLI’yi, yeni container görüntünüz yeni oluşturduğumuz ECS kümesine nasıl planlanması gerektiğini belirten yeni bir görev tanımı oluşturmak için kullanacaksınız.

    CLI komutuna yapılan bir girdi olarak hizmet verecek bir JSON dosyası mevcuttur.

    IDE’de ~/environment/aws-modern-application-workshop/module-2/aws-cli/task-definition.json açın.

    Belirtilen değerleri oluşturulan kaynaklardan uygun olan biriyle değiştirin.

    Bu değerler, daha önce kopyaladığınız CloudFormation yanıtınızdan aynı zamanda daha önce ECR’ye ilettiğiniz docker görüntü etiketi çekilecektir. Örneğin, REPLACE_ME_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mythicalmysfits/service:latest

    task-defintion.json’da değerleri değiştirdiğiniz ve kaydettiğiniz zaman ECS’de yeni bir görev tanımı kaydetmek için aşağıdaki komutu uygulayın:

    aws ecs register-task-definition --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/task-definition.json
  • A: Network Load Balancer Oluşturun

    Kaydedilen yeni görev tanımı ile hizmet yığınımızda gereken altyapıyı tedarik etmeye hazırız. Doğrudan hizmetimizi internete maruz bırakmak yerine hizmet kullanımızın önüne oturtmak için bir Network Load Balancer (NLB) tedarik edeceğiz. Bu, istek üzerine arka uç hizmetimizin esnek bir şekilde özgürce ölçeği arttırması veya azaltması sağlarken veya hatalar oluşursa ve yeni container’ların tedarik edilmesi gerekirse yönlendirilen web sitesi kodumuzun tek bir DNS adıyla iletişime geçmesini sağlayacaktır

    Yeni bir NLB tedarik etmek için Cloud9 terminalinde aşağıdaki CLI komutunu uygulayın (kaydettiğiniz CloudFormation çıktısından alt ağları alın):

    aws elbv2 create-load-balancer --name mysfits-nlb --scheme internet-facing --type network --subnets REPLACE_ME_PUBLIC_SUBNET_ONE REPLACE_ME_PUBLIC_SUBNET_TWO > ~/environment/nlb-output.json

    Bu komut başarılı bir şekilde tamamlandığında IDE nlb-output.json adında yeni bir dosya oluşturulacaktır. DNSName, Vpcld ve LoadBalancerArn daha sonraki adımlarda kullanacaksınız.

    B: Yük Dengeleyici Hedef Grubu Oluşturun

    Daha sonra NLB hedef grubunu oluşturmak için CLI kullanın. Bir hedef grup AWS kaynaklarının yük dengeleyici yönlendirmek için aldığı istekler için hedef olarak kaydetmesini sağlar. Hizmet container’larımız, NLB’den tedarik edildiklerinde trafik alabilmeleri için otomatik olarak bu hedefe kaydolacaklardır. Bu komut, değiştirilmesi gerekecek bir değer içermektedir; CloudFormation tarafından geri gönderilen önceden kaydedilen MythicalMysfitsCoreStack çıktısında bir değer olarak bulunabilen vpc kimlik bilgileriniz.

    aws elbv2 create-target-group --name MythicalMysfits-TargetGroup --port 8080 --protocol TCP --target-type ip --vpc-id REPLACE_ME_VPC_ID --health-check-interval-seconds 10 --health-check-path / --health-check-protocol HTTP --healthy-threshold-count 3 --unhealthy-threshold-count 3 > ~/environment/target-group-output.json

    Bu komut tamamlandığında çıktısı IDE’nizdeki target-group-output.json dosyasına kaydedilecektir. TargetGroupArn değerine bir sonraki adımda başvuracağız.

    C: Yük Dengeleyici Dinleyicisi Oluşturun

    Sonraki adım olarak NLB için bir yük dengeleyici dinleyicisi oluşturmak için CLI kullanın. Bu, yük dengeleyicisinin belirli bir bağlantı noktasından alınan isteklerin yukarıdaki hedef gruba kayıtlı hedeflere yönlendirilmesi gerektiğini bildirir. Belirtilen iki değerin, önceki adımlarda kaydettiğiniz TargetGroup ve NLB’den uygun ARN ile değiştirildiğinden emin olun.

    aws elbv2 create-listener --default-actions TargetGroupArn=REPLACE_ME_NLB_TARGET_GROUP_ARN,Type=forward --load-balancer-arn REPLACE_ME_NLB_ARN --port 80 --protocol TCP
  • A: ECS için Hizmetle Bağlantılı Bir Rol Oluşturun

    Geçmişte ECS kullandıysanız bu adımı atlayıp bir sonraki adıma geçebilirsiniz. Daha önce hiç ECS kullanmadıysanız IAM’da ECS hizmetine hesabınızda ECS API istekleri yapmak için izin veren **hizmet bağlantılı rol** oluşturmamız gerekmektedir. Bunun gerekli olmasının sebebi, ECS’de bir hizmet oluşturduğunuzda hizmet, Docker görüntüleri çekmek, yeni görevler oluşturmak vb. gibi eylemler gerçekleştirmek için hesabınızda API’ler çağıracaktır.

    Bu rolü oluşturmazsanız ECS hizmetine gerekli eylemleri gerçekleştirmek için izin verilmez. Rolü oluşturmak için terminalde aşağıdaki komutu uygulayın:  

    aws iam create-service-linked-role --aws-service-name ecs.amazonaws.com

    Yukarıdaki adım halihazırda mevcut olan rol için hata verirse görmezden gelebilirsiniz çünkü rolün geçmişteki hesabınızda otomatik olarak oluşturulduğunu belirtmektedir.

    B: Hizmeti Oluşturun

    NLB’nin oluşturulmasından ve yapılandırılmasından ve ECS hizmetinin uygun izinleri verdikten sonra container’larımızın çalışacağı ve trafik almak için kendilerini yük dengeleyicisine kaydedecekleri asıl ECS **hizmetini** oluşturmaya hazırız. `~/environment/aws-modern-application-workshop/module-2/aws-cli/service-definition.json` lokasyonunda bulunan CLI girdisi için bir JSON dosyası oluşturduk. Bu dosya, bu hizmetin **AWS Fargate** ile başlatılması gerektiğini belirten ayrıntılar dâhil olmak üzere hizmetin oluşturulabilmesi için gereken tüm yapılandırma ayrıntılarını içermektedir - bu da hedeflenen kümede herhangi bir sunucuyu tedarik etmek zorunda kalmayacağınız anlamına gelmektedir. Bu hizmette kullanılan görevin bir parçası olarak planlanan container’lar tamamen AWS tarafından yönetilen kümenin üzerinde çalışacaktır.

    IDE’de ~/environment/aws-modern-application-workshop/module-2/aws-cli/service-definition.json açın ve REPLACE_ME olarak belirlenen değerleri değiştirin. Kaydedin ve hizmeti oluşturmak için aşağıdaki komutu çalıştırın:

    aws ecs create-service --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/service-definition.json
    C: Hizmeti Test Edin

    NLB’yi oluştururken kaydettiğiniz DNS adını kopyalayın ve Cloud9’daki ön izleme tarayıcısını kullanarak istek gönderin (veya basit bir şekilde web tarayıcısı ile çünkü bu sefer hizmetimiz internette erişilebilir durumdadır). Mysfits kaynağına istek göndermeyi deneyin:

    http://mysfits-nlb-123456789-abc123456.elb.us-east-1.amazonaws.com/mysfits

    Daha önce Docker container’ını yerel olarak Cloud9’da test ettiğinizde aldığımız aynı JSON yanıtını gösteren bir yanıt Flask API’nızın açık ve AWS Fargate üzerinde çalışır durumda olduğunuz anlamına gelmektedir.

    Not: Bu Network Load Balancer yalnızca HTTP (http://) isteklerini desteklemektedir çünkü üzerinde hiçbir SSL/TLS sertifikası yüklü değildir. Bu öğretici için yalnızca http:// kullanarak istek sunduğunuzdan emin olun çünkü https:// istekleri düzgün çalışmayacaktır.

  • A: API Uç Noktasını Değiştirin

    Daha sonra, daha önce S3’ yüklediğimiz sabit kodlanmış verileri kullanmak yerine yeni API arka ucunuzla web sitemizi entegre etmemiz gerekmektedir. API çağrıları için aynı NLB URL kullanmak için aşağıdaki dosyayı güncellemeniz gerekecektir (/mysfits yolunu dâhil etmeyin): /module-2/web/index.html

    Cloud9’da dosyayı açın ve aşağıda tırnakların arasında işaretlenen alanı NLB URL ile değiştirin:

    before-replace

    Yapıştırdıktan sonra satır aşağıdakine benzer görünmelidir:

    after-replace
    B: S3’e Yükleyin

    Bu dosyayı S3’te barındırılan web sitenize yüklemek için Modül 1 sırasında oluşturulan klasör adını tekrar kullanınve aşağıdaki komutu çalıştırın:

    aws s3 cp ~/environment/aws-modern-application-workshop/module-2/web/index.html s3://INSERT-YOUR-BUCKET-NAME/index.html

    AWS Fargate’e dağıtılan Docker container’ı içerisinde çalışan Flask API’nizden JSON verileri alan yeni Mythical Mysfits web sitenizi görmek içinModül 1’in sonunda kullanılan aynı URL’yi kullanarak web sitenizi açın!

Modül 2C: AWS Code Services kullanarak Dağıtımları Otomatikleştirin

Kullanıma hazır bir hizmetiniz olduğunuza göre Flask hizmetinize yapmak isteyebileceğiniz kod değişikliklerini düşünebilirsiniz. Hizmetinize her yeni bir özellik dağıtmak istediğinizde yukarıdaki aynı adımları gerçekleştirmek gelişim hızınız için bir tıkanıklık yaratabilir. İşte tam burada sıra, Sürekli Entegrasyon ve Sürekli Teslim veya CI/CD’ye gelir!

Bu modülde, en son modül sırasında oluşturduğunuz hizmetin kod tabanına yaptığınız kod değişikliklerinin tamamını otomatik olarak teslim eden tam olarak yönetilir bir CI/CD yığını oluşturacaksınız.

Mimari Diyagramı

dinamik bir web sitesi mimarisi oluşturun - cloud9, kod araçları, fargate
  • A: İşlem Hattı Yapıtları için bir S3 klasörü Oluşturun

    CI/CD işlem hattı yürütmelerimizin ortasında oluşturulan geçici yapıtları depolamak için kullanılacak olan başka bir S3 klasörü oluşturmamız gerekecektir. Bu yapıtlar için yeni bir klasör adı seçin ve aşağıdaki CLI komutunu kullanarak yeni bir tane oluşturun:

    aws s3 mb s3://REPLACE_ME_CHOOSE_ARTIFACTS_BUCKET_NAME

    Sonraki adım olarak bu klasörün, içerisinde depolanan veriler için izin tanımlanması için bir klasör politikasına ihtiyacı vardır. Fakat herkesin erişimine açık olan web sitesi klasöründen farklı olarak yalnıza CI/CD işlem hattımızın bu klasöre erişimi olmalıdır. Bu politika için gereken JSON dosyasını ~/environment/aws-modern-application-workshop/module-2/aws-cli/artifacts-bucket-policy.json dosyasında sağladık.

    Bu dosyayı açın ve daha önce MythicalMysfitsCoreStack’ın bir parçası olarak oluşturulan ARN’leri dâhil etmek için birkaç dizeninyanında CI/CD yapıtları için yeni seçtiğiniz klasör adını da değiştirmeniz gerekecektir.

    Bu dosyayı değiştirip kaydettiğinizde CI/CD işlem hattınıza erişim için klasöre izin vermek için aşağıdaki komutu çalıştırın:

    aws s3api put-bucket-policy --bucket REPLACE_ME_ARTIFACTS_BUCKET_NAME --policy file://~/environment/aws-modern-application-workshop/module-2/aws-cli/artifacts-bucket-policy.json
    B: CodeCommit Deposu Oluşturun

    Kodunuzu iletip depolayabileceğiniz bir yere ihtiyacınız olacak. Bu amaçla CLI kullanarak **AWS CodeCommit deposu** oluşturun:

    aws codecommit create-repository --repository-name MythicalMysfitsService-Repository
    C: CodeBuild Projesi Oluşturun

    Kodunuzu depolayacak bir depo ve CI/CD yapıtları için kullanılacak bir S3 klasöründen sonra CI/CD yığınına hizmet oluşturmanın gerçekleştirilebilmesi için bir yol ekleyelim. Bu, bir AWS CodeBuild Projesi oluşturularak gerçekleştirilebilir. Her bir yapı yürütme işlemi tetiklendiğinde AWS CodeBuild, otomatik olarak yapılandırmamıza bir oluşturma sunucusu tedarik edecek ve Docker görüntümüzü oluşturmak için gereken adımları uygulayıp oluşturduğumuz ECR deposuna onun yeni bir versiyonunu iletecektir (ve daha sonra oluşturma tamamlandığında sunucuyu kapatın).

    Oluşturmamız için gereken adımlar (Python kodumuzu paketleyen ve Docker container’ını oluşturan/ileten) ~/environment/aws-modern-application-workshop/module-2/app/buildspec.yml dosyasına dâhil edilmiştir. buildspec.yml dosyası, CodeBuild’a talimat vermesi için oluşturduğunuz ve bir CodeBuild projesinde bir yapı yürütme için hangi adımların gerekli olduğunu belirten dosyadır.

    CodeBuild projesini oluşturmak için başka bir CLI girdi dosyasnın kaynaklarınıza özel parametreler ile güncellenmesi için gereklidir. Şurada bulunur ~/environment/aws-modern-application-workshop/module-2/aws-cli/code-build-project.json. Benzer şekilde bu dosyanın içerisinde değerleri, MythicalMysfitsCoreStackOutput’da daha önce yaptığınız gibi değiştirin. Kaydettiğinizde projeyi oluşturmak için aşağıdaki CLI’yi uygulayın :

    aws codebuild create-project --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/code-build-project.json
    D: CodePipeline İşlem Hattı Oluşturun

    Son olarak, her bir kod değişikliği depoya gönderildiğinde derlemelerin otomatik olarak gerçekleşmesi için CodeCommit deposunu CodeBuild projesi ile sürekli olarak entegre etmek için bir yola ihtiyacımız var. Daha sonra bu yeni oluşturulan yapıtların ECS’deki hizmetimize sürekli olarak teslim etmemiz için bir yola ihtiyacımız var. AWS CodePipeline, sıradaki iş olarak oluşturacağınız işlem hattında bu eylemleri birbirine yapıştıran bir hizmettir.

    CodePipeline’daki işlem hattınız yukarıda bahsettiğim şeyi yapacaktır. Her ne zaman bir kod değişikliği CodeCommit deposuna iletildiğinde bir derlemenin oluşması için CodePipelin'de en güncel kodu AWS CodeBuild projesine teslim edecektir. CodeBuild ile başarılı bir şekilde oluşturulduğunda CodePipeline, CodeBuild yürütmesinin ECR’ye ilettiği en güncel container görüntüsünü kullanarak ECS’ye bir dağıtım gerçekleştirecektir.

    Tüm bu adımlar, işlem hattını oluşturmak için AWS CLI’ye yapılan bir girdi olarak kullandığınız sürece bir JSON dosyasında tanımlanır. Bu dosya ~/environment/aws-modern-application-workshop/module-2/aws-cli/code-pipeline.json dosyasında bulunur; açın ve içerisinde gerekli öznitelikleri değiştirin ve dosyayı kaydedin.

    Kaydettikten sonra aşağıdaki komut ile CodePipeline’da bir işlem hattı oluşturun:

    aws codepipeline create-pipeline --cli-input-json file://~/environment/aws-modern-application-workshop/module-2/aws-cli/code-pipeline.json
    E: ECR Görüntü Deposuna Otomatik Erişimi Etkinleştirin

    CI/CD işlem hattımızın uçtan uca başarılı bir şekilde yürütülebilmesi için son bir adımımız kaldı. CI/CD işlem hattı mevcutken artık container görüntülerini ECR’ye manuel olarak iletmeniz gerekmeyecektir. Artık CodeBuild yeni görüntüleri iletecek.

    CodeBuild’e bir ECR depo politikası* ile görüntü deponuzda eylem gerçekleştirebilmesi için izin vermemiz gerekmektedir. Politika belgesinin MythicalMysfitsCoreStack tarafından oluşturulan CodeBuild rolü için özel ARN ile güncellenmesi gerekmektedir; politika belgesi ~/environment/aws-modern-application-workshop/module-2/aws-cli/ecr-policy.json dosyasında bulunmaktadır.

    Bu dosyayı güncelleyin ve kaydedin; daha sonra politikayı oluşturmak için aşağıdaki komutu çalıştırın:

    aws ecr set-repository-policy --repository-name mythicalmysfits/service --policy-text file://~/environment/aws-modern-application-workshop/module-2/aws-cli/ecr-policy.json

    Bu başarılı bir şekilde oluşturulduğunda kod değişikliklerini otomatik olarak ECS’deki hizmetinize teslim eden çalışan bir uçtan uca CI/CD işlem hattına sahip olursunuz.

  • A: AWS CodeCommit ile Git Kullanımı

    Yeni işlem hattını test etmek için Cloud9 IDE’nizde git’i yapılandırmamız ve CodeCommit deponuz ile entegre etmemiz gerekmektedir.

    AWS CodeCommit, entegrasyonu kolaylaştırmak için kullanacağımız git için credential helper sunmaktadır.

    Git’in AWS CodeCommit ile kullanılabilmesi için terminalde aşağıdaki komutları art arda çalıştırın (başarılı olursa hiçbiri bir yanıt raporlamayacaktır):

    git config --global user.name "REPLACE_ME_WITH_YOUR_NAME"
    git config --global user.email REPLACE_ME_WITH_YOUR_EMAIL@example.com
    git config --global credential.helper '!aws codecommit credential-helper $@'
    git config --global credential.UseHttpPath true

    Daha sonra terminali kullanarak IDE’nizdeki dizinleri ortam dizini olarak değiştirin:

    cd ~/environment/

    Şimdi aşağıdaki terminal komutu kullanarakdepomuzu klonlamaya hazırız:

    git clone https://git-codecommit.REPLACE_REGION.amazonaws.com/v1/repos/MythicalMysfitsService-Repository

    Bu bize, depomuzun boş olduğunu söyleyecek! Bunu aşağıdaki komutu kullanarak uygulama dosyalarınıdepo dizinine kopyalayarak düzeltelim:

    cp -r ~/environment/aws-modern-application-workshop/module-2/app/* ~/environment/MythicalMysfitsService-Repository/
    B: Bir Kod Değişikliği İletme

    Modül 2’de Fargate hizmetini oluşturmak için kullandığımız tamamlanmış hizmet kodu, az önce AWS CodeCommit’ten klonladığımız yerel depoda depolanmaktadır. Oluşturduğumuz CI/CD işlem hattının çalıştığını göstermek için değişikliklerimizi uygulamadan önce Flask hizmetinde bir değişiklik yapalım. Cloud9’da ~/environment/MythicalMysfitsService-Repository/service/mysfits-response.json dosyasında depolanan dosyasını açın ve mysfit’lerden birinin yaşını başka bir değer ile değiştirin ve dosyayı kaydedin.

    Dosyayı kaydettikten sonra dizinleri yeni depo dizinleri ile değiştirin:

    cd ~/environment/MythicalMysfitsService-Repository/

    Daha sonra kod değişikliklerinizi iletmek için aşağıdaki git komutlarını çalıştırın.

    git add .
    git commit -m "I changed the age of one of the mysfits."
    git push

    Değişiklik depoya iletildikten sonra değişiklikleriniz CI/CD işlem hattında ilerlerken görüntülemek için AWS Console’da CodePipeline hizmetini açabilirsiniz. Kod değişikliğinizi uyguladıktan sonra değişikliklerin Fargate’te çalışan canlı hizmetinize dağıtılması 5-10 dakika sürecektir.

    Bu sırada AWS CodePipeline, değişiklikler CodeCommit deponuza girdiğinde bir işlem hattı yürütmesi tetikleyerek düzenleyecek, yeni bir derleme başlatmak için CodeBuild projenizi tetikleyecek ve CodeBuild tarafından ECR’ye iletilen docker görüntüsünü alıp hizmetinizde çalışan mevcut container’ları boşaltmak ve bunları yeni oluşturulan görüntüyle değiştirmek için otomatik ECS Hizmeti Güncelleme eylemi gerçekleştirecektir. Değişikliklerin geçerlilik kazandığını görmek için tarayıcınızda Mythical Mysfits web sitenizi yenileyin.

    Kod değişikliğinizin ilerlemesini CodePipeline konsolu aracılığıyla görüntüleyebilirsiniz (hiçbir eylem gerektirmez, yalnızca otomasyonun nasıl çalıştığını izletin!): AWS CodePipeline

    Bu Modül 2’yi sonlandırmaktadır.

Sonraki adım olarak mysfit verisi depolayın.