Asp.NET Core API Uygulamasını Amazon ESC’ye Deploy Etme – AWS Fargate İle Dockerize Operasyonu

Merhaba,

Bu içeriğimizde, bir Asp.NET Core API uygulamasının Amazon Elastic Container Services(Amazon ECS)‘a nasıl deploy edileceğini ve uygulamayı dockerize etmeyi detaylıca inceleyecek ve bu süreçte Amazon açısından ihtiyaç duyulacak olan servisleri ele alıyor olacağız. O halde buyurun başlayalım…

Amazon Elastic Container Services(Amazon ECS) Nedir?

Amazon Elastic Container Services, Amazon Web Services(AWS) tarafından sunulan, Docker container’larının yönetilmesi ve çalıştırılmasından sorumlu olan bir servistir. ECS, kullanıcılara yüksek ölçeklenebilir ve güvenli bir şekilde uygulamaları çalıştırma ve yönetme için gerekli altyapıyı sağlamaktadır.

ECS, bir docker container’ını özelleştirilmiş bir bilgisayar sunucusuna yerleştirir, ayrıca yüksek performans ve ölçeklenebilirlik sağlamak için otomatik olarak kaynakların yönetimini üstlenir. Bu, uygulamaların daha hızlı başlatılmasını ve kullanıcıların ihtiyaçlarına göre esnek bir şekilde ölçeklendirilmesini sağlar.

ECS, AWS’nin diğer hizmetleriyle de entegre olabilir. Misal olarak; Amazon Elastic Load Balancer(ELB) ile birlikte kullanılarak load balancing operasyonu gerçekleştirilebilir yahut Amazon CloudWatch Logs ile birlikte kullanılarak container log’ları takip edilebilir.

AWS Fargate Nedir?

AWS Fargate, AWS tarafından sunulan bir container servisidir. Amazon Elastic Container Service(Amazon ECS) ve Amazon Elastic Kubernetes Service(Amazon EKS) ile entegre edilebilmektedir. Fargate, container’ların çalıştırması için kullanıcı açısından gerekli olan sunucu yönetimini tamamen ortadan kaldırmakta ve container’ları doğrudan bir sanal özel bulut(VPC) içerisinde çalıştırmaktadır.

Fargate, kullanıcıların ECS veya EKS aracılığıyla yönetilen container servislerini kullanırken, sunucuları yönetme yahut ölçeklendirme gibi konularda endişelenmelerine gerek duyulmaksızın uygulama container’larını çalıştırmalarına olanak sağlamakta ve tüm bunların yanında otomatik bir şekilde ölçeklendirme(automatic scaling), load balancing, service discovery ve güvenlik(security) gibi pek çok özellik sunmaktadır.

Ayrıca Fargate, kullanıcıların uygulamalarını çalıştırmak için sadece gerektiği kadar kaynak kullanmalarına olanak tanıyan bir kaynak yönetimi modeli sunmakta ve böylece uygulama performansını artırmak için gereksiz yere kaynakların boşa harcanması durumunu ortadan kaldırmaktadır.

Amazon ECS İle İlgili Bilinmesi Gereken Bazı Terminolojiler

Task	Service	Cluster
Bir veya birden fazla container içerebilen uygulama çalıştırma bileşenidir. Task, çalıştıracağı container’a dair image, port, protokol vs. gibi bilgileri barındırmakta ve bu yapılandırmalar doğrultusunda container’ı ayağa kaldırmaktadır.	Birden fazla task instance’ını çalıştırmak için kullanılan yapılandırmadır. Task’ların işlemlerini koordine ederek yük dengelemesi, yüksek kullanılabilirlik, ölçeklenebilirlik ve performans sağlar. Bir task başarısız olduğu taktirde diğer task’ların hizmet sağlamaya devam etmesinden, ayrıca otomatik olarak yeni task’ların oluşturulup ölçeklendirilmesinden sorumludur. Böylece kaynak yönetimini oldukça kolaylaştırmaktadır. Ayrıca container’ın sürüm kontrolü servis sayesinde sağlanmaktadır.	Bir grup kaynakların(instance’ların) kümesidir. Cluster, container’ların tek bir mantıksal birimde, yüksek performanslı ve ölçeklenebilir bir şekilde yönetilmesine ve koordine edilmesine olanak tanır.

İçerik Rotamız Nasıl Olacak?

Bu içerğimizde temelde bir Asp.NET Core API uygulaması için oluşturulan docker image’inin Amazon Elastic Container Registry(ECR)‘e yüklenmesini ve AWS ECS’de nasıl barındırılabileceğini ele alıyor olacağız. Bu nedenle, öncelikle .NET API uygulamasını oluşturacak ve local’deki MongoDB örneğiyle gerekli test işlemlerini gerçekleştireceğiz. Akabinde bu uygulama için bir Dockerfile dosyası hazırlayacak ve oluşturduğumuz docker image’ini Amazon ECR’ye yükleyeceğiz. ECR’de tanımlanmış olan docker image’ini çekmek(pull) ve çalıştırmak(run) için görev tanımları(task definition) olan bir ECS Cluster oluşturacağız.

ESC’nin temel mantığı, her ECS Cluster’ın “n” task definition’a sahip olacağıdır ve buradaki her bir task definition, uygulama deploy yaklaşımımıza bağlı olarak birden fazla docker container’ı içerebilir. Task definition oluşturulduktan sonra bir servis bu görev tanımına dayalı olarak oluşturulabilmektedir. Haliyle biz, bir cluster oluşturacak ve daha sonra biri MongoDB image’ini diğeri de ECR’den .NET uygulamasını çeken iki task tanımında bulunacak ve sonrasında da bu task’ları çalıştıracak olan servislerin oluşturulmasını gerçekleştirip, uygulamayı deploy etmiş olacağız.

Şimdi gelin tüm bu süreci hep beraber tecrübe edelim…

Örnek Çalışma

Şimdi gelin içeriğimizde hedeflediğimiz konuları adım adım örneklendirmeye başlayalım.

• 1. Adım (API Oluşturma ve MongoDB Entegrasyonunu Sağlama)
  Örneklendirmeyi gerçekleştirebilmek için bir Asp.NET Core Web API uygulaması oluşturunuz ve ardından MongoDB çalışmalarını yürütebilmek için MongoDB.Driver kütüphanesini kurunuz. Devamında ise ‘BooksController’ isminde bir controller sınıfı oluşturunuz ve aşağıdaki entity eşliğinde controller’ın içeriğini tasarlayınız.

      public class Book
      {
          [BsonId]
          [BsonRepresentation(BsonType.ObjectId)]
          public string? Id { get; set; }
          public string? Name { get; set; }
          public string? Author { get; set; }
          public string? PublishedYear { get; set; }
      }
  

      [Route("api/[controller]")]
      [ApiController]
      public class BooksController : ControllerBase
      {
          readonly IMongoCollection<Book> _bookCollection;
          public BooksController(IConfiguration configuration)
          {
              MongoClient mongoClient = new(configuration["MongoDBConfigurations:ConnectionString"]);
              IMongoDatabase database = mongoClient.GetDatabase(configuration["MongoDBConfigurations:Database"]);
              _bookCollection = database.GetCollection<Book>(configuration["MongoDBConfigurations:BookCollection"]);
          }
  
          [HttpGet]
          public async Task<IActionResult> Get()
              => Ok(await _bookCollection.Find(b => true)
                                      .ToListAsync());
  
          [HttpPost]
          public async Task<IActionResult> Post(Book book)
          {
              await _bookCollection.InsertOneAsync(book);
              return Ok(book.Id);
          }
      }
  

  Evet, görüldüğü üzere local olarak yapılandırılmış, MongoDB altyapısında, veritabanına kitap ekleyen ve tüm kitapları sorgulayarak elde etmemizi sağlayan bir API kurgulanmış bulunmaktadır. Tabi burada isterseniz, best practices açısından controller’da ki business logic’i farklı bir servise alıp oradan yürütmeyi gerçekleştirebilir ve Options Pattern‘ı kullanarak konfigürasyonları yürütebilirsiniz. Bizler içeriği çok fazla şişirmemek için bu sadelik seviyesinde seyre devam edeceğiz.

  Ayrıca konfigürasyonel değerleri ‘appsettings.json’ dosyasında aşağıdaki gibi tutabilirsiniz:

  {
    "Logging": {
      "LogLevel": {
        "Default": "Information",
        "Microsoft.AspNetCore": "Warning"
      }
    },
    "AllowedHosts": "*",
    "MongoDBConfigurations": {
      "ConnectionString": "mongodb://localhost:27017",
      "Database": "AmazonESCDB",
      "BookCollection": "Books"
    }
  }
  

• 2. Adım (Uygulamayı Dockerize Etme)
  Şimdi oluşturduğumuz uygulamayı dockerize edebilmek için öncelikle Dockerfile’ı oluşturalım. Bunun için uygulamanın ana dizinine(root) ‘Dockerfile’ isminde bir dosya ekleyiniz ve içeriğini aşağıdaki gibi doldurunuz.

  FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
  WORKDIR /src
  
  COPY . .
  RUN dotnet restore
  
  COPY . .
  RUN dotnet publish -c release -o /app/publish
  
  FROM mcr.microsoft.com/dotnet/aspnet:7.0
  WORKDIR /app/publish
  COPY --from=build /app/publish ./
  
  EXPOSE 80
  
  ENTRYPOINT ["dotnet", "Amazon.ESC.AspNETCore.WebAPI.Deploy.Example.API.dll"]
  

  Ve ardından uygulamanın ana dizinine odaklanmış bir powershell ya da cmd açarak aşağıdaki talimat eşliğinde bu Dockerfile üzerinden bir docker image oluşturunuz.

  docker build -t amazon-esc-aspnetcore-webapi-deploy-example-api .

  Bu talimat neticesinde Dockerfile içerisindeki talimatların sırasıyla işlendiğini ve ilgili image’ın aşağıdaki ekran görüntüsünde olduğu gibi Docker Desktop üzerinden de gözlemlenebildiği şekliyle başarıyla oluşturulduğunu görüyoruz.Artık oluşturduğumuz uygulamanın local’de image’ını aldığımıza göre bunu Amazon ECS’nin de erişebileceği şekilde internete göndermemiz gerekmektedir. Bunun için ilgili image’ı Amazon ECR’ye yani Amazon Elastic Container Registry‘e gönderiyor olacağız.

• 3. Adım (Image’i Amazon ECR’ye Push’lama)
  Yukarıdaki adımda bahsedildiği gibi tarafımızca oluşturulan docker image’lerine Amazon ECS’den erişim gösterilebilmesi için güvenli bir şekilde depolanmasını ve dağıtılmasını sağlayan bir havuza göndermemiz gerekmektedir. Bunun için yüksek performanslı barındırma hizmeti sunan Amazon ECR’yi kullanacağız. Tabi sizler isterseniz Amazon ECR’ye alternatif olarak Docker Hub’ı da kullanabilirsiniz.

  Bunun için öncelikle AWS Console üzerinden ECR servisini açınız ve aşağıdaki gibi bir repository oluşturunuz.Görüldüğü üzere bizler ‘amazon-ecs-aspnetcore-webapi-deploy-example’ adında bir repository oluşturmuş bulunuyoruz. Bu işlemin ardından oluşturulan docker image’ı Amazon ECR’de oluşturulan bu repository’e göndermek için Dockerfile’ın bulunduğu dizini tekrardan powershell yahut cmd ile açınız ve aşağıdaki talimatları veriniz.

  aws ecr get-login-password | docker login --username AWS --password-stdin 567921601443.dkr.ecr.ap-south-1.amazonaws.com
  docker tag amazon-esc-aspnetcore-webapi-deploy-example-api 567921601443.dkr.ecr.ap-south-1.amazonaws.com/amazon-esc-aspnetcore-webapi-deploy-example
  docker push 567921601443.dkr.ecr.ap-south-1.amazonaws.com/amazon-esc-aspnetcore-webapi-deploy-example
  

  Eğer ki, login sürecinde problem yaşıyorsanız aşağıdaki talimatı deneyiniz.

  powershell 'docker login --username AWS -p $(aws ecr get-login-password --region <<region>> ) ****.dkr.ecr.<<region>>.amazonaws.com'

  Bu işlem neticesinde AWS Console’dan ECR servisine gidip gönderilen image’i aşağıdaki gibi doğrulamanızda fayda vardır.

• 4. Adım (Docker Image’i Local’de Test Etme)
  Şimdi uygulamamızın image’ini AWS ECR’ye gönderdiğimize göre, ufaktan local’de bir test gerçekleştirmekte fayda vardır. Bunun için aşağıdaki docker talimatını vermeniz yeterli olacaktır;

  aws ecr get-login-password | docker login --username AWS --password-stdin 567921601443.dkr.ecr.ap-south-1.amazonaws.com
  docker run -p 8080:80 -e MongoDBConfigurations:ConnectionString='mongodb://host.docker.internal:27017' -e ASPNETCORE_ENVIRONMENT=Development amazon-esc-aspnetcore-webapi-deploy-example-api
  

  Burada ilk olarak yine docker’da oturum açıyor ardından ‘8080’ portunda oluşturduğumuz image’dan bir container ayağa kaldırıyoruz. Ayrıca container’da kullanılacak olan MongoDB connection string değerini environment olarak verdiğimize dikkatinizi çekerim.Görüldüğü üzere ilgili talimat çalıştırıldığı taktirde uygulama ayağa kalkmakta ve http://localhost:8080/api/books adresine yapılan istek neticesinde aşağıdaki görüntüde olduğu gibi kayıtlı kitaplar tarafımıza döndürülmektedir.Evet, uygulamamızın gayet sağlıklı bir şekilde çalıştığını gözlemlemiş olduk. Şimdi sıra uygulamayı Amazon ECS’ye deploy etmeye geldi.

• 5. Adım (Amazon ECS’ye Cluster’ının Oluşturulması)
  İlk olarak Amazon ECS’yi kullanabilmek, MongoDB ve dotnet uygulamalarını çalıştırabilmek için bir ECS Cluster oluşturulması gerekmektedir. Bunun için aşağıdaki görselde olduğu gibi AWS Console üzerinden ECS servisine aratarak gidiniz.Ardından aşağıdaki gibi cluster’ı oluşturunuz.Görüldüğü üzere ‘amazon-esc-aspnetcore-webapi-deploy-example-api-cluster’ isminde bir cluster oluşturulmuştur.

  Şimdi bu işlemi yaptıktan sonra oluşturulan cluster’a servis ve task(görev) ekleme işlemlerini gerçekleştirmemiz gerekmektedir.

• 6. Adım (MongoDB Task’ı Oluşturma ve AWS ECS Cluster’ıyla İlişkilendirme)
  Öncelikle cluster’da biri servis görevi görecek diğeri ise MongoDB’yi yürütecek task tanımında bulunmamız gerekmektedir. Bunun için ECS servisinin menüsünden yandaki gibi ‘Task definitions’ sayfasına geliniz ve açılan sayfada ‘Create new task definition’ butonuna tıklayınız.

  İlk olarak aşağıdaki gibi MongoDB task’ını yapılandıralım.Bu yapılandırmada container ve image adıyla birlikte bağlantı noktaları önem arz etmektedir. Image adının ‘mongo’ olmasına dikkat ediniz. Bu şekilde yapılandırma neticesinde ilgili image’ı Docker Hub’dan çekecektir.

  Şimdi task tanımlama sürecinin bir sonraki adımında ise task’ın boyutunu ve çalışacağı işletim sistemini belirleyiniz.Görüldüğü üzere bizim çalışmamızda yüksek trafik söz konusu olmayacağı için minimum değerlerde CPU ve RAM değerlerini seçmiş bulunuyoruz. Tabi ki de sizler yazılımınızın işlem hacmine göre buradaki değerleri belirlemeniz gerektiğinin farkındasınız.

  Velhasıl, bu temel yapılandırmalar eşliğinde MongoDB task’ını oluşturunuz ve ‘Task definitions’ sayfasında aşağıdaki gibi listelendiğini görerek, oluşturulduğundan emin olunuz.Evet, MongoDB task’ı oluşturulduğuna göre artık cluster ile ilişkilendirebiliriz. Bunun için ‘Clusters’ sayfasından ilgili cluster’a tıklayarak, aşağıdaki ekran görüntüsünde olduğu gibi sayfanın hemen aşağısındaki ‘Tasks’ sekmesine geliniz ve ‘Run new task’ butonuna tıklayınız.Açılan sayfada cluster ile aşağıdaki yapılandırmalar eşliğinde ilgili task’ı ilişkilendiriniz.Bu işlemin ardından cluster üzerinden ‘Tasks’ sekmesine tekrar gelirsek eğer oluşturulan task’ın cluster ile ilişkilendirildiğini ve biraz bekleyince çalıştırıldığını gözlemleyebiliriz.

• 7. Adım (AWS ECS Cluster’ına MongoDB Servisi Ekleme)
  Şimdi de cluster’a MongoDB servisi eklememiz gerekmektedir. Bunun için ilgili cluster üzerinden aşağıdaki ekran görüntüsünde olduğu gibi ‘Services’ sekmesine geliniz ve ‘Create’ butonuna tıklayınız.Devamında ise açılan sayfada aşağıdaki yapılandırmalar eşliğinde servisi oluşturunuz.Ayrıca bu servise bir load balancer bağlayarak endpoint oluşturabilmek için aynı sayfada hafif aşağıda bulunan ‘Load balancing’ kısmında da aşağıdaki yapılandırmaları gerçekleştiriniz.Bu işlemden sonra ‘Services’ sekmesinde oluşturulan servisi gözlemleyerek, emin olunuz.
• 8. Adım (27017 Portuna Trafik İzninin Verilmesi)
  Şimdi 27017 portuna trafik izninin verilmesini gerçekleştirelim. Bunun için ilgili cluster içerisinde aşağıdaki ekran görüntüsünde olduğu gibi servise tıklayınız, açılan sayfada ‘Networking’ sekmesi üzerinden ‘Security groups’ bağlantısına tıklayarak VPC yapılandırmalarına geliniz.Ardından aşağıdaki ‘Inbound rules’ listesinden ilk rule’u seçerek sağ taraftaki ‘Edit inbound rules’ butonuna tıklayınız.Ve açılan sayfada aşağıdaki gibi yapılandırmayı gerçekleştiriniz.
• 9. Adım (Uygulamayı ECS’ye Deploy Etme)
  Ve son olarak uygulamayı ECS’ye deploy edelim. Bunun için ilk olarak MongoDB task’ının IP’sini almamız gerekmektedir. Bunu da aşağıdaki ekran görüntüsünde olduğu gibi edinebilirsiniz.Şimdi ‘Task definitions’dan aşağıdaki ekran görüntüsündeki gibi uygulama ayarlarını barındıracak olan bir task oluşturunuz.Burada dikkat ederseniz ‘book-manager-task’ının bağlantı sağlayacağı MondoDB’nin connection string’i environment olarak verilmekte ve biraz önce edindiğimiz IP bu noktada kullanılmaktadır. Ayrıca container image’ı olarak ECR’ye göndermiş olduğumuz repository’nin kullanıldığına dikkatinizi çekerim. Velhasıl kelam, oluşturulan bu task’ı cluster’da ayağa kaldırınız.Malumunuz az beklediğiniz taktirde task’ın ‘Running’ statüsüne geldiğini göreceksiniz.

  Aynı şekilde cluster üzerinden uygulama için aşağıdaki gibi service oluşturunuz.Aşağıdaki gibi load balancer tanımlamasını da gerçekleştiriniz.Ve böylece her iki servisimiz de hizmete hazır…

• 10. Adım (Test Etme)
  Yukarıdaki adımlar doğru bir şekilde uygulandığı taktirde API’ın ECS’ye başarılı bir şekilde deploy edildiğini varsayabiliriz. Tabi ki de bunu doğrulayabilmek için son olarak test yapmak en makuludur. Testi gerçekleştirebilmek için ise uygulama servisi üzerinden endpoint’e erişmemiz gerekmektedir. Bunun için de aşağıdaki gibi ‘Networking’ sekmesinden ‘DNS names’ altındaki bağlantı üzerinden uygulamanın endpoint’ine erişebilirsiniz.Uygulamamızda swagger aktif olduğu için yukarıdaki görselde olduğu gibi endpoint sonuna ‘/swagger’ yazıp request’te bulunduğumuz taktirde swagger arayüzü tarafından karşılanıyorsanız her şey yolundadır demektedir.

  Son olarak API’ın swagger arayüzü sayesinde testini gerçekleştirip veritabanına başarıyla erişebildiğini tecrübe ettiyseniz artık makaleyi burada noktayalabilirsiniz 🙂

Nihai olarak yaptıklarımızı özetlememiz gerekirse eğer;

1. ASP.NET Core API uygulaması oluşturarak Docker image’ını oluşturduk.
2. Oluşturulan Docker image’ını depolamak ve yönetebilmek için AWS Container Registry(ECR)’ye yükledik.
3. Amazon ECS’de bu uygulamaya ait container’ları yönetip, koordine edeceğimiz cluster tanımında bulunduk.
4. Veritabanı(MongoDB) container’ı için bir task oluşturduk ve cluster’da ayağa kaldırdık.
5. Yine veritabanı(MongoDB) container’ını/task’ını çalıştırabilmek için bir servis oluşturduk ve bu servise IP tanımlayabilmek için load balancer ekledik.
6. Oluşturulan MongoDB servisinin 27017 portuna erişim için trafik izni verdik.
7. Uygulamayı Amazon ECS’ye deploy edebilmek için uygulamaya dair bir container barındıracak task oluşturduk ve bunu da cluster’da ayağa kaldırdık. Burada uygulamanın image’ını 2. adımda depoladığımız AWS Container Registry’den çektik.
8. Ve son olarak uygulama task’ını çalıştıracak olan servisi oluşturup yine IP tanımlayabilmek için bu servise de load balancer ekledik.

İşte bu kadar… 🙂

İlgilenenlerin faydalanması dileğiyle…
Sonraki yazılarımda görüşmek üzere…
İyi çalışmalar…

Kaynaklar;
https://aws.amazon.com/tr/ecs/features/
https://codewithmukesh.com/blog/deploy-aspnet-core-web-api-to-amazon-ecs/

Not : Örnek projeyi aşağıdaki github adresinden edinebilirsiniz.
https://github.com/gncyyldz/Amazon.ESC.AspNETCore.WebAPI.Deploy.Example