Nedir Bu Docker?

Merhaba, uygulamalarımızı hazırlarken iş akışlarının oluşturmak, dizayn ve kodlama süreçlerini tamamlamanın yanında en önemli sorunlarda biri de uygulamanın nerede ve nasıl çalışacağının belirlenmesi adımıdır. Uygulamanın host edilmesi, çalışma zamanı kontrollerinin sağlanması, çalışılan uzak makinenin teknik altyapısının uygunluğu veya zaman içinde uygulamanın performans ihtiyaçlarına göre bu teknik özelliklerin artış / düşüş göstermesi kodlama aşamasından daha yorucu hale gelebilmektedir.

Özellikle son zamanlarda sıkça duyduğumuz mikro servis mimarisinin de hayatımıza girmesi ile birlikte dağıtık yapıların ismini daha çok telaffuz eder olduk konuşmalarımızda. Böyle bir durumda uygulamalarımızı nasıl ve nerede barındıracağız ve yöneteceğiz?

Bu makalemizde bu soruların cevaplarını bulmaya çalışırken Docker uygulamasının ne olduğundan, avantajlarından ve kullanımından bahsedeceğiz. Tabii bu arada ASP.NET Core uygulamalarımızı Docker ile nasıl yayınlayacağımız konusuna da değineceğiz.

Barındırma, hosting ve büyük zorluklar.

Hayatımıza bulut teknolojileri girmeden önce – yaşımdan dolayıASP barındırma hizmetlerine kadar gidebilirim fakat bunlarla canınızı sıkmak istemiyorum – barındırma hizmetleri için anlaştığımız firmalar ile çoğu zaman bir savaş veriyorduk. Ana makinelerin konfigürasyon ayarları, ek bellek veya işlemci ihtiyaçlarının sağlanması konularında tam bir kaos yaşanabiliyordu. Ardından gelen bulut teknolojileri ile birlikte bu sorunların büyük kısmının önüne geçmiş olundu. Hatta artık bu gibi ihtiyaçlarımızı birilerini arayarak veya e-posta göndererek değil kendimiz bir, iki küçük araç ile halleder duruma geldik.

Bu yeniliklerin için inceleceğimiz konu olan Docker da barındırma işlerimizi kolaylaştırmak adına bir araç olarak bize sunuluyor. Şimdi dilerseniz kavramları biraz inceleyelim ardından bu işlemleri nasıl yapılıyor beraber bakalım.

Docker mı ?

Docker uygulamasının temel amacı geliştirdiğimiz uygulamaların yayınlama ve çalıştırma süreçlerini kendi yapısında bulunan konteynerler (container) üzerinde gerçekleştirmesidir. Docker bu işlemleri yaparken bizleri çalıştığı işletim sisteminden soyutlayarak, her biri ayrı konteynerler üzerinde çalışan ve birbirlerini etkilemeyen uygulama grupları oluşturmamıza izin vermektedir.

Docker Mimarisi

Docker ilk olarak Linux ortamlar için geliştirilmiş ve daha sonrasında Windows ve MacOS işletim sistemlerine yayılmış bir uygulamadır. Uygulama çalışma mantığı olarak iki bölümden oluşmaktadır. Bunlardan ilki Linux çekirdeği ile direkt iletişim halinde olan Docker Deamon. İkinci bölüm ise kullanıcının yani bizim Deamon ile iletişim kurmamızı sağlayan Docker CLI.

Linux işletim sistemlerinde bu için bölüm direkt Linux ile haberleşirken Windows ve MacOS işletim sistemlerin Deamon bir sanal makine üzerinde koşturulmaktadır. Docker CLI ise yine kullanılan işletim sistemi üzerinde çalışmaya devam etmektedir.

Docker Deamon ve CLI iletişimi istem – sunucu yapısında çalışmaktadır. Deamon ile CLI soket veya REST API üzerinden iletişim kurabilmektedir. Bu sayede Docker Windows ve MacOS işletim sistemlerinde de çalışabilmesinin yanı sıra bir Docker CLI ile istediğimiz bir Docker Deamon’a da bağlanabilmekteyiz.

Docker Mimarisi ile ilgili görseli aşağıda bulabilirsiniz.

Birazda Docker ile beraber hayatımıza girecek olan yeni terimlere bakalım.

İmaj (Image) :

Docker tarafından çalıştırılacak olan konteynerlerin şemalarını temsil ederler. Konteynerlerin içerisinde bulunan işletim sistemini, dosya sistemini veya konteyner içerisinde kullanılacak olan uygulamaları barındırır. Eğer mevcutsa bir imaj başka bir imajdan kalıtım alarak da tanımlanabilir. İmaj dosyasının içeriği Dockerfile adı verilen bir dosya içerisinde tutulmaktadır. Dosyalar Docker hub içerisinde veya yerel ortamınızda depolanabilmektedir.

Konteyner (Container) :

Konteynerler bir imaj dosyasında oluşturulan tek bir ana bilgisayar içerisinde birden çok uygulamayı çalıştırmak için kullanılan yapılardır. Aslında bu işlem sanallaştırmaya benzer, ancak birden çok işletim sistemi oluşturmak için bir sunucuyu sanallaştırmak yerine konteynerler, işletim sistemini esasen sanallaştırarak daha hafif bir alternatif sunar. Böylelikle birden çok iş yükünün tek bir ana bilgisayarda çalışmasına izin verir. Her konteyner kendi dosya, ağ ve uygulama yapısına sahiptir.

Docker CLI (Command-Line Interface) – Docker İstemcisi :

Docker ile çalışırken kullanacağımız komut setlerini barındırmaktadır. Aslında temel olarak Docker Deamon ile kullanıcı arasındaki iletişimi sağlar. İmajların indirilmesi, indirilen imajlardan konteynerlerin oluşturulması ve bu konteynerlerin yönetilmesi Docker CLI ile yapılmaktadır.

Docker Daemon :

Asıl işi yapan kısımdır. Burada imajlardan oluşturulan konteynerlerin tüm yaşam döngüsünden sorumlu bölümdür. Dosya sisteminin kontrolü ve kaynakların sınırlandırılması (CPU ve RAM) burada yapılmaktadır.

Docker Hub :

İmaj dosyalarını indirip kullanabildiğimiz, yeni imaj dosyalarını ayarlayarak yükleyebildiğimiz bir alan olarak kullanılmaktadır.

Haydi Docker ile çalışalım!

Yazının ilerleyen bölümlerinde Docker ile bir imajın oluşturulması, bu imajdan bir konteyner oluşturulması ve bunun oluşturacağımız bir ASP.NET Core uygulaması yayınlanması konularına bakacağız.

İlk önce Docker Deamon ve CLI kurulumlarının nasıl yapıldığını inceleyelim.

Docker Kurulumu

Eğer bir Linux makine için kurulum işlemlerini yapacaksanız bu adresten adımları takip edebilirsiniz.

Eğer macOS bir makine için kurulum işlemlerini yapacaksanız bu adresten adımları takip edebiliriniz.

Kurulum işlemlerini Windows işletim sistemi üzerinden anlatmaya çalışacağım. .NET Core SDK kurulum işlemlerinin tamamlanmasının ardından Docker kurulum adımlarına bakabiliriz.

Öncelikle bu adresten kurulum dosyasının indirerek kurulum aşamalarını tamamlıyoruz.

Kurulum aşamaları tamamlandıktan sonra Docker Desktop uygulaması aşağıdaki şekilde olacaktır.

Docker üzerinden oluşturacağınız konteynerler için ihtiyacınız olan imaj dosyalarına Docker Hub üzerinden ulaşabileceğinizden daha önce bahsetmiştik. Bu işlem için öncelikle hub.docker.com adresine kayıt olmanız ve bir DockerId almanız gerekmektedir.

.NET Core MVC Uygulamamızı hazırlayalım.

İlk önce uygulamamızı hazırlayacağımız klasörü ve dotnet cli ile projemizi oluşturmamız gerekmektedir. Bunun için projemizi oluşturmak istediğimiz klasörü oluşturduktan sonra komut satırı editöründen oluşturduğumuz klasöre giderek aşağıdaki komut satırının çalıştırmamız yeterli olacaktır.

dotnet new mvc

Böylece projemiz için gerekli temel yapıyı oluşturuyoruz. Projemizi test etmek için ise komut satırı editörüne aşağıdaki satırı yazarak uygulamamızın hazır olmasını sağlayabilir, ardından uygulamamızı kontrol ettiğimiz zaman aktif bir şekilde çalıştığını görebiliriz.

dotnet run

Dockerfile diyorduk. Ne oldu ona?

Evet, uygulamamızın çalıştığını da gördükten sonra makalemizin ana konusu olan Docker ile uygulamamızı nasıl yayınlayacağımız konusunu inceleyeceğiz.

Öncelikle uygulamamızın Docker ile bağlantılı olabilmesi için bir Dockerfile oluşturmamız ve bu dosyanın tanımlarının yapmamız gerekmektedir. Uygulamamızın bulunduğu bir kod editörü ile açıp ardından Dockerfile tanımlarımızı yapmaya başlayabiliriz. Makale içerisinde editör olarak Visual Studio Code kullanılacaktır. VS Code ile uygulamamızın bulunduğu klasörü açabilmek için komut satırından uygulamamızın bulunduğu klasöre giderek code . komut satırının çalıştırmamız yeterli olacaktır.

Projemizin kök dizininde Dockerfile (büyük, küçük uyumuna dikkat etmemiz gerekiyor.) isminde bir dosya oluşturarak içeriğini aşağıdaki gibi tanımlıyoruz.

Dockerfile (büyük küçük uyumu önemli) Docker tarafından okunarak imaj dosyalarının oluşturulması sağlayan bir komut dosyası olarak düşünülebilir. Dockerfile içerisinde yapmak istediklerimizi biraz açıklamak gerekirse;

FROM : Docker konteynerinin hangi imaj örnek alınarak (kalıtım) oluşturulacağının tanımlandığı yerdir. Burada dikkat edilmesi gereken konu uygulamanız hangi .NET Core versiyonunda ise o versiyona uygun bir baz imaj seçmeniz gerektiğidir.

WORKDIR : Konteynerin çalışma dizin bilgisidir.

COPY : Kaynaktan hedefe kopyalanacak dosya bilgilerini içerir. Bu örneğimizde csproj dosyasının imaj dosya sistemi içerisine kopyaladıktan sonra dotnet restore komut satırı ile uygulamamızın çalışması için gereklilikleri yüklemiş oluyoruz.

RUN : İmaj içerisinde çalıştırmak istediğimiz komut bilgisidir. Burada dotnet publish ile uygulamamızı yukarıda belirttiğimiz yol ve özelliklere göre yayınlamış olacağız.

ENTRYPOINT : Docker konteyneri için bir çalışma bilgisi (executable) tanımlarını içerir. Burada bizim oluşturduğumuz proje konteyner için başlangıç noktası olacaktır.

Ve Sahne Docker’da

Şimdi ise uygulamamızın Docker içerisinde yayınlanması konusuna bakalım. İlk olarak komut satırı editörümüzden yine uygulamamızın çalışma dizininde iken aşağıda komut satırının çalıştırarak imajımızı derleyelim.

docker build -t hellodocker . 

Bu komut ile birlikte Docker tanımlara uygun bir şekilde gerekli olan imaj dosyalarının indirecek ve yeni bize ait olan imaj dosyamızı oluşturacaktır.

Ardından imajımızın doğru oluşturup oluşturulmadığı kontrol etmek için aşağıda bulunan komut satırını kullanabiliriz.

docker images

Eğer önceki ekranda bir problem ile karşılamadıysanız burada oluşturduğumuz imajı görebileceğiz. İmajın boyutu, id bilgisi ve ismi liste içerisinde gelecektir.

Bu işlemleri de tamamladıktan sonra artık oluşturduğumuz imajdan bir konteyner oluşturarak çalışır hale getirebiliriz. Konteyner ile birlikte de uygulamamız Docker üzerinde barındırılıp, yayınlanmış olacaktır. Bu işlemi yapabilmek için yine komut satırı editöründe aşağıda bulunan komutu çalıştırıyoruz.

docker run -d -p 8080:80 --name HelloDocker hellodocker

Biraz önce oluşturduğumuz konteynerin ve şu an Docker ile yayınlanan diğer konteynerlerin durumlarını öğrenmek için ise aşağıdaki komut yeterli olacaktır.

docker ps

Burada oluşturduğumuz konteynerin STATUS bilgisinin Up olduğunu görebilmekteyiz. Evet şimdi de uygulamamızı konteynerimizi aktif ederken belirttiğimiz port ve özelliklere göre kontrol edelim.

Gördüğünüz gibi uygulamamız artık Docker üzerinden yayınlanmaya başladı ve özelliklerini belirttiğimiz port üzerinden de bu kontrolü yapabiliyoruz.

Konteynerler ile işimiz belli bir süre sonra bitebilir ve aktif olarak yayınlanmasını hatta bunların Docker Registery içinde bulunmamasını istemeyebilir. Peki, mevcut konteynerleri nasıl durdurup, silebiliyoruz? Son olarak bu komutlara da göz atalım. Aşağıda bulunan komut ile çalışan bir konteyneri durdurabiliyoruz. Bunun için daha önceden kullandığımız docker ps komutu ile konteyner listesini alarak durdurma işleminde bu liste üzerinden bize verilmiş olan isimleri kullanacağız.

docker stop hellodocker

docker rm HelloDocker komut satırı ile konteynerimizi silebiliyor ve docker rmi hellodocker komut satırı ile de daha önceden oluşturduğumuz imaj dosyamızı silerek sistemden kaldırabiliyoruz.

Komut satırı ile yaptığımız bu işlemleri de yine Docker kurulumu ile beraber gelen Docker Desktop uygulaması ile de yapmamız mümkündür.

Evet, bir makalenin daha sonunda geldik. Bu makalede Docker nedir ? Docker ile bir uygulamamızı nasıl konteyner olarak barındırırız ve nasıl yönetiriz? konularının anlatmaya çalıştım. Umarın yararlı olmuştur.

Bir başka makalede görüşmek üzere.

Kaynaklar :

https://gokhansengun.com/docker-nedir-nasil-calisir-nerede-kullanilir/
https://medium.com/@teo.levy/getting-started-with-asp-net-core-docker-guide-for-beginners-d62af654881a
https://kancerezeroglu.wordpress.com/2016/06/17/docker/
https://medium.com/devopsturkiye/temel-d%C3%BCzeyde-docker-mant%C4%B1%C4%9F%C4%B1-ve-kavramlar%C4%B1-bde5418858d4

ASP.NET Core Web API ve Swagger

Merhaba,

ASP.NET Core ile birlikte çeşitli projeler geliştirebiliyoruz. Bu proje tiplerinden en önemlisi ise API projeler. API nedir? ASP.NET Core Web API bize neler sağlar? ve Swagger isimli ürün ile API’nin nasıl bir ilgisi olacak bu makalede bunları incelemeye çalışacağız.

Nedir bu API dedikleri?

API uzun adıyla Application Programming Interface, temel olarak farklı türden uygulamaların beraber çalışmalarını sağlayan yazılımlar olarak düşünülebilir. API uygulamalar arasında veri alışverişlerini sağlar. Tabii bu veri transferleri sırasında güvenlik, yetkilendirme ve yine genel uygulama mantığında kullanılan işlemlerin hepsi kullanılmaktadır. En belirgin fark ise API uygulamalarının bir arayüzlerinin (GUI) olmamasıdır.

API üzerinden alınan değerler ile -bazen de değer almadan- yapılan işlemlerin sonuçları (database crud, başka uygulamalardan veri almak vb.) başka uygulamalar tarafından okunabilir şekilde verilebilmektedir. Böylelikle farklı platformlarda çalışan, farklı teknolojilere sahip uygulamaların tamamı aynı API’ye veri gönderebilir ve sonuçları alarak kendi yapıları üzerinde değerlendirebilirler.

API teknolojilerinin günümüzde en bilinen kullanım yeri mobil uygulamaların arka tarafında bulunan servisler (backend) olarak karşımıza çıkar. Mobil uygulama ister IOS ister Android platformunda olsun aynı API üzerinden verileri okur ve işlemlerini yapabilir.

ASP.NET Core Web API ne oluyor o zaman ?

API aslında bir teknoloji, bir yapı olarak bahsedilen bir kavram. Tabii ki bir API uygulaması farklı diller ile yazılabilmektedir. Biz bu makalemizde ASP.NET Core ile bir API uygulamasının nasıl oluşturulacağının inceleyeceğiz.

ASP.NET Core ile ilgili daha içerikli bilgi için Nedir bu ASP.NET Core ?makalesini inceleyebilirsiniz.

ASP.NET Core Web API projemizi oluşturalım ardından Swagger nedir ? Nasıl kullanılır? İncelememize devam edelim.

Projemiz ile çalışmak için Visual Studio Code kullanacağız. Yeni bir ASP.NET Core projesi oluşturuyoruz. Projemiz için .NET Core CLI’den yaralanacağız. İlk önce webapi projemizi aşağıdaki gibi oluşturuyoruz.

Ardından uygulamamızı test etmek için dotnet run komutunu çalıştıralım ve oluşturulmuş olan API’mizi kontrol edelim.

Uygulamızın adresini komut çalıştırıldıktan sonra görebilmekteyiz. http://localhost:5000 bu adres üzerinden tarayıcımız ile uygulamamızı kontrol edebiliriz. Yeni oluşturulan iskelet uygulama içerisinde test edebilmemiz veya yeni başlayanlar için örnek olması açısında bir Controller hazır bir şekilde gelecektir. (WeatherForecast) bu controller üzerinden API’mizi test edebiliriz.

Bir başka test yöntemi ise API geliştiricilerini sıklıkla kullandığı POSTMAN uygulamasıdır. POSTMAN uygulamasını buradan indirebilirsiniz. POSTMAN, API’ler ile çalışmak için kullanılan bir uygulamadır. Tarayıcılar üzerinden API verilerini almanın veya isteklerin gönderilmesinin zorluğunu yaşamamak için POSTMAN kullanılmaktadır. POSTMAN üzerinden de API üzerinden bulunan controller aşağıdaki şekilde bize verileri getirmektedir.

Dilerseniz şimdi bir kod yazmaya geçebiliriz. Şimdi kendimiz bir controller oluşturarak buradan verilerin (statik olarak) gelmesini sağlayacağız. Ardından API üzerinde oluşturduğumuz bu controller’ı test edip Swagger ile çalışmamıza bakabileceğiz.

Yeni controller oluşturmak için Visual Studio Code kullanacağız projemizi Visual Studio Code ile açmak için yine komut satırı üzerinde code . yazmamız yeterli olacaktır.

Projemiz Visual Studio Code ile ilk açıldığı zaman uygulama projemizi build ve debug edebilmek için gerekliliklerin yüklenmesini isteyip / istemediğimizi bize soracaktır. Bu kısımda Yes butonu ile gerekliliklerin yüklemesini tamamlayabiliriz.

Yeni oluşturacağımız Controller temel araç bilgilerini API üzerinden servis edecektir. Bunun için ilk önce araç modelimizi oluşturmalıyız. Sol dosya gezgini üzerinden Models isminde yeni bir klasör açarak Car.cs isminde bir dosya oluşturuyoruz. Ardından bu dosyaya modelimizi yazıyoruz.

namespace ASPNETCoreSwagger.Models
{
    public class Car
    {
        public int Id { get; set; }
        public string Brand { get; set; }
        public string Model { get; set; }
        public int Year { get; set; }
    }
}

Ardından Controllers klasörü altında yeni bir dosya oluşturarak adına CarController.cs veriyoruz. Burada bir araç listesi ile ilgili işlemler yapacağız ve bu işlemleri API üzerinden servis edeceğiz.

CarController.cs dosyamız ise aşağıdaki gibi olacaktır.

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using ASPNETCoreSwagger.Models;
namespace ASPNETCoreSwagger.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class CarController : ControllerBase
    {
        [HttpGet]
        public IEnumerable<Car> Get()
        {
            return GetCars();
        }
        [HttpGet("{id}", Name = "Get")]
        public Car Get(int id)
        {
            return GetCars().Find(e => e.Id == id);
        }
        [HttpPost]
        [Produces("application/json")]
        public Car Post([FromBody] Car car)
        {
            return new Car() { Id = car.Id, Brand = car.Brand, Model = car.Model, Year = car.Year };
        }
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] Car car)
        {
            
        }
        
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
        private List<Car> GetCars()
        {
            return new List<Car>()
            {
                new Car() { Id = 1, Brand = "Toyota", Model = "Auris", Year = 2012 },
                new Car() { Id = 2, Brand = "BMW", Model = "3.20", Year = 2019 },
                new Car() { Id = 3, Brand = "Renault", Model = "Clio", Year = 2020 }
            };
        }
    }
}

Şimdi oluşturduğunuz Controller’ı kullanarak API’mizi test edebiliriz.

Visual Studio Code üzerinden açacağımız terminal üzerinde dotnet run yazarak uygulamamızı çalıştıralım. POSTMAN üzerinden hem liste hem de istediğimiz araç bilgisine ulaşabilmekteyiz.

Buraya kadar API’mizin oluşturulması ile ilgili çalışmalar yaptık. Peki bu API’yi kullanacak olan uygulamaların geliştiricilerine API ve çalışması ile ilgili bilgiyi nasıl ileteceğiz ? Diyelim ki mobil uygulama geliştiren bir takımın içerisinde backend servislerini geliştiriyoruz. Mobil uygulamaları geliştiren ekip üyelerine bu geliştirdiğimiz metodların nasıl çalıştığı hakkında bilgi vermemiz gerekir. Hem metodların çağırılmaları hem de geri dönen cevap bilgilerinin doküman haline getirilip iletilmesi en sağlıklı yöntem olacaktır.

Böyle bir durumda her metodu tek tek belirli bir formatta yazmak elbette yorucu olacaktır. Bu durumu daha kolay ve pratik hale getirmek için Swagger ideal bir ürün olarak karşımıza çıkıyor.

Swagger eklediğimiz projemizde oluşturduğumuz metod bilgilerini otomatik olarak dokümante eder. Bu metod bilgileri her istekleri (request) hem de cevap (response) bilgileri ile birlikte API’mizi kullanmak isteyen uygulama geliştiriciler tarafından görüntülenebilir.

Swagger iki bölümden oluşmaktadır. Bunlardan ilki ve en önemlisi Swagger Specification‘dır. Burada Swagger tarafından otomatik olarak oluşturulan bir swagger.json dosyası mevcuttur ve her API güncellemesinde bu dosya güncellenerek API içerisinde bulunan metodlarımızın bilgilerini barındırır.

İkinci bölüm ise Swagger UI olarak adlandırılmaktadır. Burada da API üzerinde bulunan metodların görsel olarak bilgilerini alabiliriz. Metodların çalışmalarını, verdikleri cevapları ve aldıkları parametre bilgileri görüntülenebilir. Ayrıca basit bir şekilde metodları çalıştırabilir ve metod cevaplarının UI üzerinden alabiliriz. Swagger UI üzerinden özellikle bir uygulama yazarak API üzerinden metodların test edilmesine gerek kalmayacaktır.

Şimdi oluşturduğumuz uygulamamıza Swagger’ı nasıl uyarlarız ona bakalım.

Swagger üç bileşenden oluşmaktadır. Tüm bu bileşenleri tek nuget paketi şeklinde uygulamamıza almamız mümkündür.

Bu bileşenler;

• Swashbuckle.AspNetCore.Swagger
• Swashbuckle.AspNetCore.SwaggerGen
• Swashbuckle.AspNetCore.SwaggerUI

Swagger paketini yükleyelim

Paketi projemize eklemek için Visual Studio Code terminal ekranından aşağıdaki komutu yazmamız yeterli olacaktır.

dotnet add package Swashbuckle.AspNetCore

Ardından paket uygulamamıza indirilmiş ve yüklenmiş olacaktır.

Swagger’ın uygulamamıza uyarlanması için ilk önce Startup.cs içerisinde bulunan ConfigureServices metoduna aşağıdaki satırları eklememiz gerekmektedir.

Yine Startup.cs içerisinde bulunan Configure metoduna da aşağıdaki satırları ekliyoruz.

Şimdi Visual Studio Code terminal ekranından uygulamamızı çalıştırıp Swagger uyarlamasının test edebiliriz. Bunun için terminal ekranına dotnet run yazmamız gerekmektedir.

Ardından tarayıcımızdan veya POSTMAN üzerinden https://localhost:5001/swagger/v1/swagger.json adresine girersek Controller bazlı metod bilgilerimizin json formatında geldiğini görebiliriz.

Peki bir UI bileşeninden bahsetmiştik. Şimdi de bu UI bileşenini nasıl kullanacağımıza bakalım.

Projemiz çalışırken https://localhost:5001/swagger/index.html adresine tarayıcımız üzerinden girdiğimiz zaman API Bilgileri başlıklı bir sayfa açılacak ve metot bilgilerimizi görüntüleyebileceğiz.

Swagger UI üzerinden metodların bilgilerini metot isimlerine tıklayarak alabiliriz.

Burada araç bilgilerini listelediğimiz metodumuzun özelliklerini görüyoruz. Parameters bölümü metodumuzun parametre bilgilerini, Responses bölümü ise API metodu üzerinden dönen cevap (response) hakkında bilgi vermektedir. Sağ üst kısımda bulunan Try it out butonu ile API metodunu çalıştırabilir dönen bilgileri de görebiliriz.

Swagger UI üzerinde metodlarımızın açıklamalarını da görüntülememiz mümkündür. Bu şekilde metodlarımızı inceleyen uygulama geliştiricilere anlamlı açıklamalar ile metodun görevini anlatmamız mümkün olmaktadır.

Bunun için uygulamamızın csproj dosyasına (bizim uygulamamız için dosya adı ASPNETCoreSwagger.csproj) aşağıda bulunan satırları eklememiz gerekmektedir.

Ardından Startup.cs dosyasında bulunan ConfigureServices metoduna da aşağıdaki satırları ekliyoruz.

Artık API metodlarımıza açıklamalar ekleyebilir ve bu açıklamaların Swagger UI üzerinden görüntülenmesini sağlayabiliriz. Metodlarımıza nasıl açıklama ekleyeceğimizin örneğini aşağıda bulabilirsiniz. Ardından Swagger UI üzerinden metot açıklamasını görüntüleyebilirsiniz.

Projemizi yeniden çalıştırıp Swagger UI üzerinden kontrol ettiğimiz zaman metod açıklamasının geldiğini görebiliriz.

Görüldüğü gibi Swagger API projelerimizde dokümantasyon işlemlerini bizler için hızlı bir şekilde çözmektedir. API’den yararlanacak olan yazılım geliştiricilerin doğru bilgilere ulaşması Swagger ile daha rahat olacaktır.

Başka bir makale ile yeniden görüşmek üzere.

Kaynaklar:
https://www.yazilimbilisim.net/c-sharp/asp-net/api-nedir/
https://code-maze.com/swagger-ui-asp-net-core-web-api/

Visual Studio Code kullanarak ASP.NET Core Projesi Geliştirme

Gereksinimler ve kurulumlar

Visual Studio Code Microsoft tarafından ücretsiz olarak dağıtılan, cross-platform olarak çalışan, Windows, Mac ve Linux işletim sistemleri için geliştirilmiş bir kod editörüdür. Microsoft Visual Studio bir IDE olarak çalışırken Visual Studio Code bir kod editörüdür. Yalnız, VS Code da Visua Studio gibi uygulama geliştirme işlemleri için gayet kullanışlı bir üründür.

Bu makalemizde VS Code kullanarak bir ASP.NET Core uygulamasının geliştirme, debug, test ve dağıtım işlemlerinin nasıl yapıldığına bakacağız.

Visual Studio Code uygulamasının indirmek için aşağıdaki bağlantıyı kullanabilirsiniz.
https://code.visualstudio.com/

Visual Studio Code kurulumunu tamamladıktan sonra ASP.NET Core projelerimizi oluşturup kullanabilmemiz için bazı uzantıların (extension) kurulumlarını yapmamız gerekmektedir. Bunun için VS Code uygulamasının açtıktan sonra Ctrl + Shift + X tuş kombinasyonu ile veya sol menüde bulunan Extensions ikonuna tıklayarak açılan ekranda “C#” aramasının yaparak çıkan ilk uzantıyı Install butonu ile kurulum işlemini tamamlayabiliriz.

Ardından aynı şekilde Nuget Gallery için uzantı kurulumunu tamamlamamız gerekmektedir.

VS Code genel olarak ASP.NET Core projelerini oluşturmak için Visual Studio gibi bir komut yapısına sahip değildir. .Net Core CLI bu konuda yazılımcılara yardımcı olmaktadır. Biz de projemizi .Net Core CLI üzerinden oluşturacağız.

İlk ASP.NET Core Uygulamamız

İlk önce projemizin oluşturulacağı dizini oluşturmamız gerekmektedir.

Ardından oluşturduğumuz klasörü VS Code ile açmamız gerekmektedir. Bunun için File menüsünden Open Folder… komutu seçilmesi yeterli olacaktır.

VS Code kendi içerisinde bir terminal yapısı barındırmaktadır. Böylelikle komut satırı kullanmadan işlemlerimizi bu terminal yapısı ile gerçekleştirmemiz mümkün olacaktır. Terminal menüsünü açmak için Terminal menüsünden New Terminal (Ctrl + Shift + “) komutunu seçmemiz yeterli olacaktır.

Terminal alt kısımda açıldıktan sonra aşağıda bulunan komut ile ilk ASP.NET Core projemizi oluşturmaya başlayabiliriz.

dotnet new mvc

Yukarıda bulunan komut Terminal ekranı üzerinde çalıştırıldığı zaman bulunduğumuz klasör içerisinde yeni bir Asp.Net Core MVC projesi oluşturulacak ve dotnet restore komutu otomatik olarak çalıştırılıp paket bilgileri de güncellenecektir.

Projemizin çalıştırılması

Projemizi çalıştırmak için yine .NET Core CLI komutlarından faydalanacağız. Bunun için terminal ekranına aşağıdaki komut yazılarak çalıştırılabilir. Böylelikle projemiz bize bilgileri verilecek olan localhost adresi ve bir port üzerinden çalışmaya başlayacaktır.

dotnet run

http://localhost:5000 adresine bir web tarayıcı ile girdiğimiz zaman projemizin çalıştığının görebiliriz.

Uygulamamızın VS Code ile birlikte açılması için (F5) ve uygulamamızı debug edebilmek için launch.json ve tasks.json dosyalarının oluşturulmasına ihtiyacımız vardır. Bu dosyaları oluşturmak için VS Code’un bir özelliğini kullanabiliriz. Bunun için projemizin olduğu klasörü VS Code ile yeniden açmamız gerekmektedir. VS Code projemizi kontrol edecek ve bize gerekli dosyaların oluşturulup oluşturamayacağının soracaktır. Oluşturulan dosya örneklerini aşağıda bulabilirsiniz.

Artık Run menüsünde bulunan Start Debugging komutu ile de projemizi çalıştırma imkanına sahip olmaktayız. Böylelikle projemiz içerisinde break point’ler kullanarak projemizi debug edebiliriz.

tasks.json ve launch.json dosyalarının VS Code üzerinden oluşturmak istersek;

Komut panelini açtıktan sonra (Ctrl + Shift + P) ardından palet içerisinden Tasks: Configure Task komutunu seçmemiz gerekmektedir. Ardından Create tasks.json file from template komutu ve gelen liste üzerinden .NET Core seçmemiz yeterli olacaktır.

launch.json dosyası için de sol bölümde bulunan Run (Ctrl + Shift + D) ekranından create a launch.json file seçeneğini seçmemiz yeterli olacaktır. Ardından projemizi çalıştırabilir ve debug işlemlerimizi yapabiliriz.

Bir başka makale ile yeniden görüşmek üzere.