Hemen bir ASP.NET Core Web API projesi oluşturalım.

dotnet new webapi --name "Example"

Projemiz de redis’in temel özelliklerini kullanmak için gerekli nuget paketini projeye dahil ediyoruz.

Not: Daha geniş kapsam da redis API’sini kullanmamıza olanak sağlayan paketler bulunuyor. İkinci bölümde detaylı olarak yer vereceğim.

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis --version 3.1.10

İlgili paketi projeye ekledikten sonra “Startup.cs” dosyasında bulunan servis tanımlarından “DistributedCache” servisini aktif hale getiriyoruz. Tanımlama yaparken yapılandırma ayarları bölümünde kullanacağamız redis’e ait host ve port bilgilerini yazıyoruz.

services.AddStackExchangeRedisCache(option =>
{
  option.Configuration = "localhost:6379";
});

Not: Host, port, connection string veya benzer bilgileri code içerisinde kullanmamaya özen gösterelim.

// appsettings.json
{
  "Redis": {
    "Host": "localhost",
    "Port": "6379"
  }
}

Bağımlılık enjeksiyonu (Dependency Injection) yardımıyla IConfiguration arayüzü (interface) ile gelen methodları kullanarak redis bilgilerini artık “appsettings.json” dosyasından okuyoruz.

services.AddStackExchangeRedisCache(option =>
{
  option.Configuration = $”{Configuration[“Redis:Host”]}:{Configuration[“Redis:Port”]}”;
});

Redis üzerinde örnek işlemleri gerçekleştirmek adına user endpoint’lerini tanımlıyoruz. İlgili class’ın constructor’ın da IDistributedCache arayüzünü (interface) bağımlılık enjeksiyonu (Dependency Injection) yardımıyla geçiyoruz.

IDistributedCache arayüzü ile gelen temel redis methodları şu an için ihtiyacımızı karşılıyor. Eklemiş olduğumuz nuget paketi Microsoft tarafından redis’in temel özelliklerini kullanmamız için geliştirilmiş olup ileri seviye özellikler için kullanılmamaktadır.

Evet artık yazma-okuma gibi işlemleri yapabiliriz. “SetString” method’unu kullanarak o an ki tarih-saat bilgisini string olarak redis’e yazıyoruz. Kullanılan method’ların async versiyonları da bulunuyor.

_distributedCache.SetString(“DATE_NOW”, DateTime.Now.ToString());

await _distributedCache.SetStringAsync(“DATE_NOW”, DateTime.Now.ToString());

Redis de bulunan “DATE_NOW” key’e ait değeri “GetString” medhod’unu kullanarak okuyoruz.

var DATE_NOW = _distributedCache.GetString(“DATE_NOW”);

“DATE_NOW” key’ini siliyoruz.

_distributedCache.Remove("DATE_NOW");

Veri oluşturulduktan sonra verilen süre sonunda otomatik olarak redis’den silinir.

var options = new DistributedCacheEntryOptions
{
  AbsoluteExpiration = DateTime.Now.AddSeconds(10)
};

_distributedCache.SetString("DATE_NOW", DateTime.Now.ToString(), options);

Bir complex type’ı redis’e yazmak için “Json” veya “Binary” serialize işlemlerininden birini tercih edebilirsiniz. Fakat genelde “Json” serialize yöntemi kullanılır. “Binary” serialize genelde dosyalarla ilgili işlemler de tercih edilir.

Hemen bir user model class’ı ekliyoruz.

// User.cs
public class User
{
  public int Id { get; set; }
  public string FirstName { get; set; }
  public string LastName { get; set; }
}

Class’ımızdan bir nesne örneği alıyoruz.

var user = new User {
  Id = 1,
  FirstName = "Anıl",
  LastName = "Atalay"
};

User model class’ımızı json serialize işlemi yapmak için projemize bir nuget paketi ekliyoruz. İlgili paket Asp.Net Core API projelerinde varsayılan olarak gelmiyor!

dotnet add package Microsoft.AspNetCore.Mvc.NewtonsoftJson --version 3.1.10

Json serialize işlemini gerçekleştiriyoruz.

var userData = JsonConvert.SerializeObject(user);

Artık elimizde bulunan string user datasını redis’e yazabiliriz. Birden fazla user yazılabilir düşüncesi ile benzersiz bir key oluşturuyoruz.

await _distributedCache.SetStringAsync($”USER_{user.Id}”, userData);

Redis’e yamış olduğumuz user nesnesini okuyalım.

var userData = await _distributedCache.GetStringAsync("USER_1");

Gelen user string datasını User class’ına deserialize işlemi gerçekleştireceğiz.

var user = JsonConvert.DeserializeObject<User>(userData);

Benzer işlemleri binary içinde yapalım. User nesnemizin json string halini byte dizisine çeviriyoruz ve “SetAsync” method’unu kullanarak redis’e yazıyoruz.

var user = new User
{
  Id = 1,
  FirstName = "Anıl",
  LastName = "Atalay"
};

var userData = JsonConvert.SerializeObject(user);

var userByte = Encoding.UTF8.GetBytes(userData);

await _distributedCache.SetAsync($"USER_{user.Id}", userByte);

Redis’den okurken ise, yazarken yaptığımız işlemlerin tersini yapıyoruz.

var userByte = await _distributedCache.GetAsync("USER_1");

var userData = Encoding.UTF8.GetString(userByte);

var user = JsonConvert.DeserializeObject<User>(userData);

Redis üzerinde temel işlemleri gerçekleştirdik. Artık oluşturmuş olduğumuz projeye devam edelim. En son user endpoint’lerini eklemiştik. GET, POST ve DELETE işlemlerine başlayalım.

Evet artık user endpoint’leri üzerinden redis’e veri yazabiliyoruz. Gerçek dünya da bu işlemler veritabanı ile gerçekleştirilir. Uygulamamızın yapısına bağlı olarak süreç değişebilir. İlk isteği veritabanı üzerinden çekip dönebilir, daha sonra veriyi redis’e yazıp diğer isteklere redis’de ki veriler ile cevap verilebilir.

Öğrenilecek çok şey, gezilecek çok yer var. Bir sonraki postumda görüşmek üzere.

Cache’lemek (önbelleğe alma) dediğimiz işlem, sık kullanılan veya nadiren değişen dataların geçici bir depolama alanının da saklamasıdır. Önbelleğe alma, performansı ve ölçeklenebilirliği artırır. Verileri önbelleğe aldığımız da, verilerin kopyası geçici depolama alanında saklanır. Böylelikle bir daha ki sefere aynı veriler talep edildiğinde geçici depolama alanından alınır ve ana veri kaynağından çok daha hızlı yüklenir.

ASP.NET Core uygulamalarında bellek (memory) üzerinde işlemler gerçekleştirebilmek için built-in olarak gelen MemoryCache servisini aktif hale getirmemiz gerekiyor. Bağımlılık enjeksiyonu (Dependency Injection) yardımıyla IMemoryCache arayüzü (interface) ile gelen methodları kullanarak bellek (memory) üzerinde okuma-yazma işlemleri gerçekleştirilir.

Hemen bir ASP.NET Core Web API projesi oluşturalım.

dotnet new webapi --name "Example"

Projeyi çalıştıralım. “https://localhost:5001/WeatherForecast”

dotnet run

“Startup.cs” dosyasında ihtiyaç duyduğumuz servis tanımını ve yapılandırma ayarlarını ekliyoruz.

// Startup.cs
services.AddMemoryCache();

Bellek (memory) üzerinde örnek işlemleri gerçekleştirmek adına user endpoint’lerini tanımlıyoruz.

İpucu: Bellek (memory) üzerinde veriler key-value şeklinde tutulur. Key benzersiz olmalıdır. Aksi takdir de varolan key’in değeri güncellenir.

“DATE_NOW” key’ine o an ki tarih ve saat bilgisini string olarak belleğe yazıyoruz.

İpucu: Mehodlar generic olduğu için her tipte veri kaydedebilirsiniz. Serialization işlemini IMemoryCache kendisi gerçekleştiriyor.

_memoryCache.Set<string>("DATE_NOW", DateTime.Now.ToString());

Bellekten “DATE_NOW” key’ine ait değeri çekiyoruz.

var value = _memoryCache.Get<string>("DATE_NOW");

Bellekten “DATE_NOW” key’ini siliyoruz.

_memoryCache.Remove(“DATE_NOW”);

Bir key’in bellekte var olup olmadığını kontrol etmek için “TryGetValue” methodu kullanılır. Key bellekte var ise method “true” döner ve value değişkenine değerini atar. Aksi durumda “false” döner.

if (_memoryCache.TryGetValue<string>("DATE_NOW", out string value))
{
  ...
}

Verilerin bellekte tutulmasıyla ilgili çeşitli yapılandırma ayarları bulunuyor. Veri oluşturulduktan sonra verilen süre sonunda otomatik olarak bellekten silinir.

var options = new MemoryCacheEntryOptions
{
  AbsoluteExpiration = DateTime.Now.AddSeconds(10)
};
_memoryCache.Set<string>("DATE_NOW", DateTime.Now.ToString(), options);

Veri oluşturulduktan sonra verilen süre boyunca veriye erişim olmaz ise, otomatik olarak bellekten silinir.

var options = new MemoryCacheEntryOptions
{
  SlidingExpiration = TimeSpan.FromSeconds(10)
};
_memoryCache.Set<string>("DATE_NOW", DateTime.Now.ToString(), options);

Bellek dolduğu anda yeni eklenecek olan verilere yer açmak adına hangi verilerin önce silineceğini belirlemek için “Priority” property’si kullanılır. Önem sırasına göre tanımlamalar yapabilirsiniz.

// CacheItemPriority.Low
// CacheItemPriority.Normal
// CacheItemPriority.High
// CacheItemPriority.NeverRemove
var options = new MemoryCacheEntryOptions
{
  Priority = CacheItemPriority.Low
};
_memoryCache.Set<string>("DATE_NOW", DateTime.Now.ToString(), options);

Bellekten bir veri silindiği zaman bir event oluşturulur ve “RegisterPostEvictionCallback” method’unda ki delege tetiklenir. Böylelikle silinen verinin neden silindiği gibi bilgilere sahip olabilir veya başka bir takım işlemler gerçekleştirebiliriz.

var options = new MemoryCacheEntryOptions();
options.RegisterPostEvictionCallback((key, value, reason, state) =>
{
  ...
});
_memoryCache.Set<string>("DATE_NOW", DateTime.Now.ToString(), options);

Bir complex type’ı belleğe yazmak için get-set method’larının generic yapısı kullanılır.

// User.cs
public class User
{
  public int Id { get; set; }
  public string FirstName { get; set; }
  public string LastName { get; set; }
}

User sınıfından bir nesne türetip belleğe yazıyoruz. Birden fazla user yazılabilir düşüncesi ile benzersiz bir key oluşturuyoruz.

var user = new User
{
  Id = 1,
  FirstName = "Anıl",
  LastName = "Atalay"
};
_memoryCache.Set<User>($"USER_{user.Id}", user);

User’a ait bellekte ki veriyi okurken get generic method’unu kullanıp bir user nesnesi elde ediyoruz.

User user = _memoryCache.Get<User>("USER_1");

Bellek üzerinde temel işlemleri gerçekleştirdik. Artık oluşturmuş olduğumuz projeye devam edelim. En son user endpoint’lerini eklemiştik. GET, POST ve DELETE işlemlerine başlayalım.

Evet artık user endpoint’leri üzerinden belleğe veri yazabiliyoruz. Gerçek dünya da bu işlemler veritabanı ile gerçekleştirilir. Uygulamamızın yapısına bağlı olarak süreç değişebilir. İlk isteği veritabanı üzerinden çekip dönebilir, daha sonra veriyi belleğe yazıp diğer isteklere bellekte ki veriler ile cevap verilebilir.

Öğrenilecek çok şey, gezilecek çok yer var. Bir sonraki postumda görüşmek üzere.

Docker: Dockerfile ile Image Oluşturmak

Merhaba sevgili okur,Docker image’ları oluşturmak için Dockerfile yönergelerini nasılkullanabileceğinizi anlatmaya çalıştım. Dockerfile için giriş veya gelişmeyazısı olarak düşünebilirsiniz. Bir önce ki yazım da Docker’ı yönetmek içinkullanabileceğiniz (docker cli) temel komut listesini[/docker…

.anilatalayAnıl Atalay

Hemen başlayalım; “dotnet cli”yı kullanarak bir web api projesi oluşturalım.

dotnet new webapi --name "MyApp"

Uygulamayı çalıştıralım

Uygulamayı test amaçlı çalıştıralım ve devam edelim.

dotnet run

Dockerfile

Uygulamamızın ana dizinine Dockerfile dosyasını ekleyelim. Temel (base) image tanımımızı yapacağız.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder

Not: Microsoft resmi image’larını Dockerhub üzerinden paylaştığı gibi aynı zaman da kendi container registry’si üzerinden de paylaşıyor.

Not: Temel (base) image’mıza dikkatli baktığımızda bir ASP.NET Core SDK’sı olduğu anlaşılıyor. Fakat bizim uygulamamızın çalışması için ASP.NET Core Runtime’ı yeterli iken neden SDK image’ını kullanıyoruz. Aslında yerine değil, birlikte. SDK image’ını uygulamayı derlemek için, Runtime image’ını ise uygulamayı çalıştırmak için kullanacağız. Detaylı bilgi için dokümantasyon sayfasına göz atabilirsiniz. (keyword: multi-stage)

Not: Uygulamanızı kendi bilgisayarınızda belirli işletim sistemleri için kişileştirilmiş ayarlar ile derleyebilir ve bu çıktılar üzerinden de image oluşturabilirsiniz. Fakat bu yöntem tavsiye edilmiyor!

Not: ASP.NET Core uygulamalarını Runtime’ı ile birlikte paketlemek ve yayınlamak mümkündür. Fakat dosya boyutunu ciddi oranda artıracaktır.

Konteyner’da ki çalışma dizinini “/source” olarak ayarlayalım. İsimlendirme tamamen sizin insiyatifinize kalmış. Bu dizini uygulama kaynak kodlarını kopyalamak için kullanacağız.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source

Uygulama kaynak kodlarını “/source” dizinine kopyalayalım.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .

Not: Geliştirme (development) ortamında kopyalama işlemi yapacağımız için, uygulama dizini içerisinde çalışma zamanından kalan dosyalar, geliştirme (development) ortamına ait ayar dosyaları veya code editörüne ait istenmeyen dosyalar olabilir. Bunlara benzer istenmeyen veya ihtiyaç olmayan dosyaları konteyner içine kopyalamak istemeyebilirsiniz. Problemi çözmek adına uygulamamızın ana dizinine “.dockerignore” dosyasını ekleyelim ve konteyner’a aktarmak istemediğimiz dosyaları belirleyelim.

# .dockerignore
.git
.gitignore
.vscode
Dockerfile
README.md
**/.DS_Store

Image’ın temelini oluşturan işletim sistemi (minimal) üzerinde bulunan paketleri güncelleyelim. Bu adım uygulamaların ihtiyaç duyabileceği paketlerin yüklenebilmesi veya güncellenmesi için örnek olarak eklenmiştir.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update

Kaynak kodlarımız artık konteyner içinde olduğuna göre derleme aşamasına geçebiliriz. Konteyner’da ki çalışma dizinini “/source/MyApp” olarak değiştirelim. Burada ki dizin sizin uygulamızın ana dizinidir.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update
WORKDIR /source/MyApp

Uygulamamızı restore edelim.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update
WORKDIR /source/MyApp
RUN dotnet restore MyApp.csproj

Uygulamayı “/app” dizini altına publish alalım.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update
WORKDIR /source/MyApp
RUN dotnet restore MyApp.csproj
RUN dotnet publish MyApp.csproj --output /app/ --configuration Release

Evet uygulamamız artık yayınlamaya hazır hale geldi. Şimdi asıl image’ı oluşturacak dockerfile talimatlarına geçelim. Temel (base) image tanımımızı yapalım.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update
WORKDIR /source/MyApp
RUN dotnet restore MyApp.csproj
RUN dotnet publish MyApp.csproj --output /app/ --configuration Release
# ------------------------------------------------------------
# Runtime
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS runtime

Konteyner’da ki çalışma dizinini “/app” olarak ayarlayalım.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update
WORKDIR /source/MyApp
RUN dotnet restore MyApp.csproj
RUN dotnet publish MyApp.csproj --output /app/ --configuration Release
# ------------------------------------------------------------
# Runtime
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS runtime
WORKDIR /app

Önceki katmanlar da publish işlemini halletmiştik. Şimdi bu işlemlerin sonucunda oluşan derlenmiş uygulamamızı “/app” dizinine kopyalayalım.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update
WORKDIR /source/MyApp
RUN dotnet restore MyApp.csproj
RUN dotnet publish MyApp.csproj --output /app/ --configuration Release
# ------------------------------------------------------------
# Runtime
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS runtime
WORKDIR /app
COPY --from=builder /app .

Konteyner başlatılırken çalışacak olan komutları ekliyoruz.

# Dockerfile
# Builder
FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS builder
WORKDIR /source
COPY src/ .
RUN apt update
WORKDIR /source/MyApp
RUN dotnet restore MyApp.csproj
RUN dotnet publish MyApp.csproj --output /app/ --configuration Release
# ------------------------------------------------------------
# Runtime
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS runtime
WORKDIR /app
COPY --from=builder /app .

Dockerize Edelim

Dockerfile’mız hazır olduğuna göre artık dockerize etme kısmına geçebiliriz. “docker build” komutunu çalıştırarak image oluşturmakla başlayalım.

docker build -t anilatalay/my_dotnetcore_app:1.0.1 .

Artık uygulamamızın bir image’ı mevcut, bu image’ı kullanarak bir konteyner oluştuyoruz.

docker run --rm -p 8080:80 anilatalay/my_dotnetcore_app:1.0.1

Uygulama konteyner içinde “8080” portunu kullanırken dışarıya “80” portu üzerinden yayınlanıyor. (http://localhost:8080/WeatherForecast)

Uygulama Image’nı Paylaşalım

Docker cli üzerinden dockerhub’a giriş yapıyoruz.

docker login

Dockerhub’a image’mızı gönderiyoruz.

docker push anilatalay/my_dotnetcore_app

Hayırlı olsun. Dockerhub üzerinde nur topu gibi image’mız var. (hub.docker.com) Artık isteyen herkes image’mızı çekebilir :)

Öğrenilecek çok şey, gezilecek çok yer var. Bir sonraki postumda görüşmek üzere.

Docker: Dockerfile ile Image Oluşturmak

Merhaba sevgili okur,Docker image’ları oluşturmak için Dockerfile yönergelerini nasılkullanabileceğinizi anlatmaya çalıştım. Dockerfile için giriş veya gelişmeyazısı olarak düşünebilirsiniz. Bir önce ki yazım da Docker’ı yönetmek içinkullanabileceğiniz (docker cli) temel komut listesini[/docker…

.anilatalayAnıl Atalay

Temel amacımız bir Node.js uygulamasını dockerize etmek olduğu için uygulamanın seviyesinin bizim senaryomuz için yeterli olduğu kanaatindeyim. “package.json” dosyası oluşturduktan sonra ihtiyacımız olan paketleri yüklüyoruz.

npm init -y
npm install

“server.js” dosyasını oluşturup hayatımıza devam ediyoruz.

Sonuç olarak; ekrana “Hello World” yazan bir servisimiz mevcut. :)

Uygulamayı çalıştıralım

npm run start

Dockerfile

Uygulamamızın ana dizinine Dockerfile dosyasını ekleyelim. Dockerhub üzerinden bulunan resmi Node.js image’nı kullanacağız.

Not: Node.js kullanılabilecek farklı sistem ve versiyonlara ait image’lar bulunuyor. Uygulamanızın ihtiyaç duyduğu versiyon ve sisteme ait etikete sahip image’ı temel (base) image olarak tanımayabilirsiniz.

# Dockerfile
FROM node:15

Not: Bir temel (base) image kullanırken versiyon numarası vermeye özen gösterin. Aksi durumda “node” image’ının “latest” versiyonu çekecektir. Uygulamanızın eski versiyona bağımlılığı var ise bazı problemlere sebebiyet verebilir ve uygulamanız düzgün çalışmayabilir.

Konteyner’da ki çalışma dizinini “/app” olarak ayarlayalım. İsimlendirme tamamen sizin insiyatifinize kalmış. Bu dizini uygulama dosyaları ile işlemleri gerçekleştirmek için kullanacağız.

# Dockerfile
FROM node:15
WORKDIR /app

Uygulama dosyalarını “/app” dizinine kopyalayalım.

# Dockerfile
FROM node:15
WORKDIR /app
COPY /src .

Not: Geliştirme (development) ortamında kopyalama işlemi yapacağımız için, uygulama dizini içerisinde çalışma zamanından kalan dosyalar, geliştirme (development) ortamına ait ayar dosyaları veya code editörüne ait istenmeyen dosyalar olabilir. Bunlara benzer istenmeyen veya ihtiyaç olmayan dosyaları konteyner içine kopyalamak istemeyebilirsiniz. Problemi çözmek adına uygulamamızın ana dizinine “.dockerignore” dosyasını ekleyelim ve konteyner’a aktarmak istemediğimiz dosyaları belirleyelim.

# .dockerignore
*/node_modules
npm-debug.log
.idea
.vscode

Not: Uygulama dosyalarını kopyalama işlemi ADD talimatı kullanılarak bir source-code repository üzerinden çekilebilir.

Uygulama dosyalarımız konteyner içinde olduğuna göre artık bağımlılıkları yükleyebiliriz. “package.json” dosyasında tanımlanmış olan paketleri yüklemeye başlayalım.

# Dockerfile
FROM node:15
WORKDIR /app
COPY /src .
RUN yarn install

Not: Uygulamanızın ihtiyaç duyduğu değişiklik, yükleme vb işlemleri ekleyebilirsiniz.

Hissediyorum sona yaklaştık. Konteyner başlatılırken çalışacak olan komutları ekliyoruz.

# Dockerfile
FROM node:15
WORKDIR /app
COPY /src .
RUN yarn install
CMD yarn run start

Not: Bir “sh” benzeri kurulum veya çalıştırma dosyası oluşturup onu da başlangıç komutu olarak tanımlayabilirsiniz.

Son olarak; uygulamamız bir web application olduğu için hangi port (2323) üzerinden yayın yapacağımızıda belirtmemiz gerekiyor. Aksi takdir de uygulamaya konteyner’ın dışından kimse erişmez.

# Dockerfile
FROM node:15
WORKDIR /app
COPY /src .
RUN yarn install
CMD yarn run start
EXPOSE 2323

Dockerize Edelim

Dockerfile’mız hazır olduğuna göre artık dockerize etme kısmına geçebiliriz. “docker build” komutunu çalıştırarak image oluşturmakla başlayalım.

docker build -t anilatalay/my_node_app:1.0.1 .

Artık uygulamamızın bir image’ı mevcut, bu image’ı kullanarak bir konteyner oluştuyoruz.

docker run --rm -p 80:2323 anilatalay/my_node_app:1.0.1

Uygulama konteyner içinde “2323" portunu kullanırken dışarıya “80” portu üzerinden yayınlanıyor.

Uygulama Image’nı Paylaşalım

Docker cli üzerinden dockerhub’a giriş yapıyoruz.

docker login

Dockerhub’a image’mızı gönderiyoruz.

docker push anilatalay/my_node_app

Hayırlı olsun. Dockerhub üzerinde nur topu gibi image’mız var. (hub.docker.com) Artık isteyen herkes image’mızı çekebilir :)

Öğrenilecek çok şey, gezilecek çok yer var. Her bir yazım da gerçek dünyaya bir adım daha yaklaşacağız. Bir sonraki postumda görüşmek üzere.

Docker: Konteyner uçar sen komutu hatırla!

Merhaba sevgili okur,Docker’ı yönetmek için kullanabileceğiniz (docker cli) temel komut listesiniörnekler üzerinden anlatmaya çalıştım. docker ps Çalışan konteyner’ları listeler. docker ps -a Çalışan çalışmayan tüm konteyner’ları listeler. docker images İndirilmiş image’ları listeler. do…

.anilatalayAnıl Atalay

Docker, Dockerfile’daki talimatları okuyarak image’ları otomatik olarak oluşturur.

Dockerfile başka bir dizinde ise -f argümanı ile dosya yolu verilebilir.

docker build -f files/Dockerfile .

Image etiketlemek için -t argümanı kullanılabilir.

docker build -t anilatalay/example:1.0.1 .

Etiket argümanı birden fazla kez kullanılabilir.

docker build -t anilatalay/example:1.0.1 -t anilatalay/example:latest .

Not: Docker daemon, Dockerfile’daki talimatları çalıştırmadan önce Dockerfile için bir ön doğrulama gerçekleştirir ve sözdizimi yanlışsa bir hata döndürür.

Not: Dockerfile’daki talimatlar sırayla ve tek tek çalıştırılır. (Deneysel bazı çalışmalar bulunuyor paralel çalıştırmak gibi..)

Docker, derleme sürecini önemli ölçüde hızlandırmak için değişiklik yok ise ara adımları (önbellek) yeniden kullanır.

# ile başlayan satırları yorum olarak değerlendirilir.

\ kodun alt satırdan devam ettiği anlamına gelir.

RUN echo hello \
world

FROM

DockerHub’da daha önce hazırlanmış olan temel(base) image’lar üzerine bir şeyler ekleyip-çıkartarak kendi nihai image’zımızı oluştuyoruz.
Not: Dockerfile bir FROM talimatı ile başlamalıdır.

# Dockerfile
FROM ubuntu

Docker build işlemi yaptığımızda bir ubuntu image’ı oluşacak. Bu image zaten var olan “ubuntu” image ile bire bir aynıdır, çünkü image üzerinde hiçbir değişiklik yapmadık.

RUN

Temel image’ın çalıştırılacağı işletim sistemi (en minimal hali) üstünde komutlar çalıştırmamızı sağlar.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet

Bir ubuntu hazırlanıyor ve içinde komutlar çalıştırılıyor. Varolan paketler güncelleniyor ve sistem üzerine “telnet” kuruluyor.

Not: Debian temelli Linux dağıtımların da “apt-get” paket yöneticisidir.
Not: Komutlarınızı farklı RUN talimatları ile kullanabileceğiniz gibi tek RUN talimatı içinde de tanımlayabilirsiniz.

# Dockerfile
FROM ubuntu
RUN apt-get update && apt-get install -y telnet

ENV

Temel image içinde bulunan işletim sistemi (en minimal hali) içinde ortam değişkenleri eklemizi sağlar.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay

Bu Image kullanılarak bir konteyner oluştuğunda ortam değişkenlerinde APP_URL görebilirsiniz.

COPY

Yolu belirtilen dosyaları, konteyner’in dosya sisteminin belirtilen dizinine kopyalar.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
COPY app/ my_app/

“app” dizini altında bulunan dosyaları, konteyner’a “my_app” dizini altına kopyalar.

WORKDIR

Dockerfile’da onu izleyen herhangi bir RUN, CMD, ENTRYPOINT, COPY ve ADD talimatları için çalışma dizinini ayarlar.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
WORKDIR /my_workplace
COPY app/ my_app/

WORKDIR komutunda sonra çalışacak olan komutların hepsi “my_workplace” dizini altında çalışacaklar. “my_app” dizini “my_workplace” altında oluşacaktır.

ADD

COPY ve ADD, benzer amaçlara hizmet eden Dockerfile talimatlarıdır. COPY yalnızca ana bilgisayarınızdan konteyner dizinine kopyalamanıza izin verir. ADD talimatı ile bunu yapabileceğiniz gibi bir URL üzerinden de dosya kopyalama yapabilirsiniz.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
WORKDIR /my_workplace
COPY app/ my_app/
ADD https://cdn.pixabay.com/photo/2020/05/12/13/38/common-blue-butterfly-5163066_1280.jpg images/

Belirtilen URL’den jpg formatında ki dosyayı images dizini altına kopyalar.

ARG

Docker build komutuyla derleme zamanında konteyner’a iletebilecekleri bir değişkeni tanımlar.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
WORKDIR /my_workplace
COPY app/ my_app/
ADD https://cdn.pixabay.com/photo/2020/05/12/13/38/common-blue-butterfly-5163066_1280.jpg images/
ARG MY_CONNECTION_STRING
ENV CONNECTION_STRING=$MY_CONNECTION_STRING

“build-arg” argümanını kullanarak “MY_CONNECTION_STRING=blabla” build aşamasında değerleri geçiyoruz. Daha sonra ENV talimatı ile ortam değişkeni olarak ekliyoruz.

docker build -t anilatalay/example:1.0.1 --build-arg MY_CONNECTION_STRING=blabla .

VOLUME

VOLUME komutu, belirtilen adda bir bağlama noktası oluşturur ve bunu yerel ana bilgisayardan veya diğer kapsayıcılardan harici olarak monte edilmiş birimleri tutuyor olarak işaretler.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
WORKDIR /my_workplace
COPY app/ my_app/
ADD https://cdn.pixabay.com/photo/2020/05/12/13/38/common-blue-butterfly-5163066_1280.jpg images/
ARG MY_CONNECTION_STRING
ENV CONNECTION_STRING=$MY_CONNECTION_STRING
VOLUME /images

EXPOSE

Docker’a, konteynerin çalışma zamanında belirtilen portu (ağ bağlantı noktaları) dinlediğini bildirir.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
WORKDIR /my_workplace
COPY app/ my_app/
ADD https://cdn.pixabay.com/photo/2020/05/12/13/38/common-blue-butterfly-5163066_1280.jpg images/
ARG MY_CONNECTION_STRING
ENV CONNECTION_STRING=$MY_CONNECTION_STRING
VOLUME /images
EXPOSE 80

Bu senaryo için çok anlamlı olmasada kullanımını göstermek istedim.

CMD

Konteyner çalıştığı anda CMD komutu ile belirtilen varsayılan komutu çalıştırır.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
WORKDIR /my_workplace
COPY app/ my_app/
ADD https://cdn.pixabay.com/photo/2020/05/12/13/38/common-blue-butterfly-5163066_1280.jpg images/
ARG MY_CONNECTION_STRING
ENV CONNECTION_STRING=$MY_CONNECTION_STRING
VOLUME /images
EXPOSE 80
CMD [ "ls" ]

CMD talimatı verilen “ls” komutu ile konteyner çalıştığı anda WORKDIR talimatın da belirtilen dizinin içindeki dosya ve klasörleri listeyecek.

docker run --rm anilatalay/example:1.0.1

Not: Çalıştır komutuna bir argüman geçerseniz, CMD talimatı geçersiz sayılır. Çıktı olarak “ls” yerine “echo merhaba” komutu çalıştırılacak.

docker run --rm anilatalay/example:1.0.1 echo merhaba

ENTRYPOINT

Konteyner’ın nasıl çalışacağını yapılandırmak için kullanılan diğer talimattır. CMD’de olduğu gibi, bir komut ve parametreler belirlemeniz gerekir.

# Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y telnet
ENV APP_URL=https://medium.com/@anilatalay
WORKDIR /my_workplace
COPY app/ my_app/
ADD https://cdn.pixabay.com/photo/2020/05/12/13/38/common-blue-butterfly-5163066_1280.jpg images/
ARG MY_CONNECTION_STRING
ENV CONNECTION_STRING=$MY_CONNECTION_STRING
VOLUME /images
EXPOSE 80
ENTRYPOINT [ "echo", "anilatalay" ]

ENTRYPOINT talimatı verilen “echo anilatalay” komutu ile konteyner çalıştığı anda ekrana çıktı olarak “anilatalay” yazacaktır.

Not: Kullanılan komutların bazıları windows konteyner’lar da sorun çıkartabilir. Detaylı bilgi için dokümantasyon sayfasına göz atabilirsiniz.

Öğrenilecek çok şey, gezilecek çok yer var. Her bir yazımda gerçek dünyaya bir adım daha yaklaşacağız. Bir sonraki postumda görüşmek üzere.

docker ps

Çalışan konteyner’ları listeler.

docker ps -a

Çalışan çalışmayan tüm konteyner’ları listeler.

docker images

İndirilmiş image’ları listeler.

docker pull alpine

Docker repository (hub.docker.com) den adı verilen (alpine) image’ı çeker.

Not: “alpine” küçük bir Linux dağıtımıdır.

docker run alpine

Adı verilen image’dan bir konteyner oluşturur ve image’a eklemiş başlangıç kodunu çalıştırır. Bu başlangıç kodu dockerfile kısmında ayrıntılı açıklayacağım. Bu kod sonladıktan sonra konteyner kapalı duruma geçer.

docker run -d jpetazzo/clock

Adı verilen image’dan bir konteyner oluşturur ve arka planda çalışmaya devam eder.

docker run --rm hello-world

Adı verilen image’dan bir konteyner oluşturur ve konteyner’ın başlangıç kodu çalıştıktan sonra konteyner otomatik olarak silinir.

docker run -it alpine

Adıverilen image’dan bir konteyner oluşturur ve konteyner’e terminal bağlantısı sağlar.

docker stop 09f8b2a5d25b

Çalışan konteyner’a kısa bir süre (10sn) sonra kapanacağını belirten bir sinyal gönderir ve süre tamamlandığında konteyner’ı sonladırılır.

docker kill 09f8b2a5d25b

Id’si verilen çalışan konteyner’ı sonladırır.

docker rm 99ae02566af7

Id’si verilen konteyner’i siler.

Not: Id kullanılan komutlar da id’nin benzersiz 3–4 karakterini de kullanabilirsiniz. (Örnek: 99ae02566af7 -> 99a)

docker rmi 321d39ea3f0f

Id’si verilen image’ı siler.

Not: Image’ı kullanan konteyner’lar bulunuyorsa silme işlemi gerçekleşmez.

docker exec -it 321d39ea3f0f sh

Çalışan konteyner’a erişmek ve içinde komut çalıştırabilmek için kullanılır.

docker run -p 8080:80 nginx

Adı verilen image’dan bir konteyner oluşturur ve 8080 portuna gelen istekleri konteyner içerisindeki 80 portuna yönlendirir.

docker logs 321d39ea3f0f

Id’si verilen konteyner’ın oluşturmuş olduğu log’ları görüntüler.

docker logs -f 321d39ea3f0f

Id’si verilen konteyner’ın oluşturmuş olduğu canlı log’ları görüntüler.

Development ortamınız da burada ki komutlar (docker cli) ile Docker’ı yönetebilirsiniz. Fakat gerçek dünya da işler tabi ki böyle yürümüyor :( Her bir yazımda gerçek dünyaya bir adım daha yaklaşacağız. Bir sonraki postumda görüşmek üzere.

Karakter

metin: merhaba dünya.
regex: /y/
tercüme: 'y' karakteri olmalı.

sonuç: merhaba dünya.
index: 8

Karakter dizisi

metin: merhaba dünya.
metin: /düny/
tercüme: 'düny' karakter dizisi olmalı.

sonuç: merhaba dünya.
index: 8

Sayılar

metin: 11111 22222 33333 44444
metin: /44444/
tercüme: 5 adet '4' karakteri yan yana olmalı.

sonuç: 11111 22222 33333 44444
index: 18

Herhangi bir karakter “.” (nokta)

” . ” (nokta) herhangi bir karakterle (harf, rakam, boşluk, her şey) eşleşebilir. Desene karakter sayısı kadar ” . ” (nokta) eklenebilir.
Not: Bu durum gerçek nokta karakterinin eşleşmesini geçersiz kıldığı için ters eğik çizgi ” \. ” ile gerçek nokta karakteri eşleşmesi sağlanır.

metin: merhaba dünya.
regex: /r..b/
not: ".." yerine nokta sayısı kadar herhangi bir karakter gelebilir demektir.
tercüme: 'r' karakteri ile başlamalı, herhangi iki karakter ile devam etmeli ve son karakteri 'b' olmalı.

sonuç: merhaba dünya.
index: 2

Herhangi bir rakam “\d”

Metin içerisinde ” \d ” herhangi bir rakamla eşleşebilir. Desene rakam sayısı kadar ” \d ” eklenebilir.

metin: abc123xyz
regex: /\d\dx/
not: "\d\d" yerine \d sayısı kadar herhangi bir rakam gelebilir demektir.
tercüme: herhangi iki rakam yan yana gelmeli ve 'x' karakteri ile devam etmeli.

sonuç: abc123xyz
index: 4

Belirli karakterler ” [ ] ” (veya)

Karakterleri köşeli parantez içinde tanımlayarak içlerinden biri ile eşleşmesini sağlayabilirsiniz.

metin: merhaba dünya.
regex: /[xyz]a/
tercüme: 'x', 'y' veya 'z' karakterlerinden biri ile başlamalı ve 'a' ile devam etmeli.

sonuç: merhaba dünya.
index: 11

Belirli karakterler hariç

Karakterleri köşeli parantez ve ^ (şapka) içinde tanımlayarak belirli karakterleri dışlayan bir desen eşleşmesini sağlayabilirsiniz.

metin: merhaba bünya cünya dünya.
regex: /[^bc]ünya/
tercüme: 'b' ve 'c' dışında herhangi bir karakter ile başlamalı, 'ünya' ile devam etmeli.

sonuç: merhaba bünya cünya dünya.
index: 20

Karakter aralıkları

Belirli karakterlerle eşleşen veya bazı karakterleri dışlayan bir desenin nasıl oluşturulduğunu anlatmaya çalıştım. Sıralı karakterleri teker teker tanımlamak yerine karakter aralığı verebiliyoruz. Örneğin, [0–6] deseni yalnızca sıfırdan altıya kadar olan herhangi bir tek haneli karakterle eşleşir. Aynı şekilde [^n-p] n’den p’ye kadar olan harfler hariç, yalnızca herhangi bir karakterle eşleşir.

metin: merhaba dünya.
regex: /[A-Za-z]ün[^cd]a/
tercüme: Büyük 'A' ile 'Z' arasında bulunan karakterlerden herhangi biri veya küçük 'a' ile 'z' arasında bulunan karakterlerden herhangi biri ile başlamalı, 'ün' ile devam etmeli, 'c' ve 'd' karakterleri dışında herhangi bir karakter ile devam etmeli ve son karakteri 'a' olmalı.

sonuç: merhaba dünya.
index: 8

Tekrar karakterler” { karakter sayısı } “

Tekrar eden karakterleri teker teker tanımlamak yerine süslü parantezler içinde tekrarlı karakter sayısını belirtebiliriz.

metin: merhaba dddünya.
regex: /d{3}ünya/
tercüme: Yan yana 3 adet 'd' karakteri ile başlamalı, 'ünya' karakter dizisi ile devam etmeli.

sonuç: merhaba dddünya.
index: 8

Limitsiz tekrar karakterler ” * “

Tekrar eden karakter sayısını bilmediğimiz durumlarda kullanılabilir. Dikkat edilmesi gereken nokta ise tekrar eden karakterin hiç olmadığı senaryolar içinde eşleşme sağlıyor oluşudur. Örneğin, “aacccc” metni için a*c* desenini yazabileceğimiz gibi, a*b*c* desenide doğru bir eşleşme sağlayacaktır. ‘b’ karakteri yokken de, n tane varken de aynı şeyi ifade etmektedir.

metin: merhaba dddünnnnya.
regex: /düny/
tercüme: 'd' karakteri 0 veya n tane yan yana başlamalı, 'ü' karakteri ile devam etmeli, 'n' karakteri 0 veya n tane yan yana devam etmeli ve 'y' karakteri ile bitmeli.

sonuç: merhaba dddünnnnya.
index: 8

Limitsiz tekrar karakterler ” + “

Tekrar eden karakter sayısını bilmediğimiz durumlarda kullanılabilir. ” * ” dan farkı ise tekrar eden karakterden en az bir tane olma zorunluluğudur.

metin: merhaba dddünnnnya.
regex: /d+ün+y/
tercüme: 'd' karakteri 1 veya n tane yan yana başlamalı, 'ü' karakteri ile devam etmeli, 'n' karakteri 1 veya n tane yan yana devam etmeli ve 'y' karakteri ile bitmeli.

sonuç: merhaba dddünnnnya.
index: 8

İsteğe bağlı karakter ” ? “

Bir karakterin ” ? ” ile kullanılması o karakterin opsiyonel olduğu anlamına gelir. Karakterin metin de bulunup bulunması göz ardı edilir.
Not: Bu durum gerçek soru işareti karakterinin eşleşmesini geçersiz kıldığı için ters eğik çizgi ” \? ” ile gerçek soru işareti karakteri eşleşmesi sağlanır.

metin: merhaba dünya.
regex: /düns?y/
tercüme: 'dün' karakter dizisi ile başlamalı, 's' karakteri ile devam etmeli veya 's' karakteri hiç olmamalı, 'y' karakteri ile bitmeli.

sonuç: merhaba dünya.
index: 8

Boşluk karakteri ” \s “

Boşluk karakterini eşleştirmek için kullanılır.
Not: Boşluk dışında herhangi bir karakter demek için ” \S ” kullanılır.

metin: merhaba dünya.
regex: /\sdün/
tercüme: ' ' (boşluk) karakteri ile başlamalı, 'dün' karakter dizisi ile bitmeli.

sonuç: merhaba dünya.
index: 7

Başlangıç ve bitiş

Metnin başlangıcında ve bitişinde eşleştirme yapabilmek için ” ^ ” ve ” $ ” kullanılır.

metin: merhaba dünya.
regex: /^merhaba\sdünya.$/
tercüme: metnin (içinde değil!) başlangıcı kesinlike 'm' karakteri ile başlamalı, 'erhaba' karakter dizisi ile devam etmeli, '\s' bir boşluk karakteri ile devam etmeli, 'dünya' karakter dizisi ile devam etmeli, metin (içinde değil!) sonu kesinlikle '.' karakteri ile bitmeli.

sonuç: merhaba dünya.
index: 0

Gruplar

Desen içerisinde karakter veya karakter dizilerini gruplamak için parantez ” ( ) ” kullanılır. Eşleşme sonuçlarını ayrı ayrı görebiliriz.

metin: merhaba dünya.
regex: /(.+)\s(.+)/
tercüme: herhangi bir karakter ile başlamalı, herhangi bir karakter dizisi ile devam etmeli, boşluk karakteri ile devam etmeli, herhangi bir karakter dizisi ile bitmeli.

sonuç: merhaba dünya.
sonuç: merhaba
sonuç: dünya
index: 0

İç içe gruplar

Desen içerisinde iç içe geçmiş karakter veya karakter dizilerini gruplamak için parantez ” ( ) ” kullanılır. Eşleşme sonuçlarını ayrı ayrı görebiliriz.

metin: merhaba dünya. 123
regex: /(.\s.\s(\d\d\d))/
tercüme: herhangi bir karakter ile başlamalı, herhangi bir karakter dizisi ile devam etmeli, boşluk karakteri ile devam etmeli, herhangi bir karakter dizisi ile devam etmeli, boşluk karakteri ile devam etmeli, yan yana 3 adet rakam ile bitmeli.

sonuç: merhaba dünya. 123
sonuç: merhaba dünya. 123
sonuç: 123
index: 0

Veya ” | “

metin: merhaba dünya. 123
regex: /.*(222|123)/
tercüme: herhangi bir karakter ile başlamalı, herhangi bir karakter dizisi ile devam etmeli, '222' veya '123' ile bitmeli.

sonuç: merhaba dünya. 123
sonuç: 123
index: 0

Regex — Konuşuyorum ama yazamıyorum

Merhaba sevgili okur,Düzenli ifadeler, temel olarak metin içerisinde belirli kurallara göre eşleştirme yapmak için kullanılır. Burada bilinmesi gereken en önemli şey her şeyin bir karakter…

MediumAnıl Atalay

Son Söz

Okuduğunuz için teşekkür ederim, bir başka post’ta görüşmek dileğiyle.