🧵 100GündeSolidity 056 : Upgradeable Proxy

Upgradeable Proxy: Solidity Smart Contract’larında Güncellemeler İçin Esnek Bir Yaklaşım

Merhaba,

Bu e-bülten serisinde #100DaysOfSolidity kapsamında “Upgradeable Proxy” konusunu ele alacağız. Solidity smart contract’larının güncellemesi sıklıkla gereken bir ihtiyaçtır ve Upgradeable Proxy, bu süreci daha esnek hale getiren bir yaklaşım sunar. Bu e-bülten serisinde, Upgradeable Proxy’nin ne olduğu, neden kullanılması gerektiği, avantajları ve dezavantajları, nasıl çalıştığı ve en iyi uygulama senaryoları hakkında bilgi edineceksiniz. Ayrıca, Upgradeable Proxy’nin dikkat edilmesi gereken güvenlik riskleri ve Solidity’de nasıl uygulanacağına dair adım adım bir kılavuz da sunacağız.

Keyifli okumalar!

Upgradeable Proxy Nedir?

Upgradeable Proxy, Solidity smart contract’larında güncellemeler yapmak için kullanılan bir yöntemdir. Bu yaklaşım, smart contract’larının daha esnek ve güncellemelere açık hale gelmesini sağlar.

Upgradeable Proxy, aslında bir proxy (ara yüz) contract’tır. Bu contract, asıl smart contract’ın fonksiyonlarını çağırmak için bir arayüz sağlar. Ancak, Upgradeable Proxy, smart contract’ın kendisini değil, smart contract’ın adresini saklar ve yönetir. Bu sayede, smart contract’ın kendisinde değişiklik yapılması gerekmediğinde bile, Upgradeable Proxy aracılığıyla smart contract’ın adresi değiştirilebilir ve yeni bir sürümü devreye alınabilir.

Bu yaklaşım, smart contract’ların güncellenmesi sırasında daha az risk alınmasını ve daha az maliyet oluşmasını sağlar. Smart contract’ların güncellenmesi, özellikle büyük projelerde oldukça sık ve önemli bir ihtiyaçtır ve Upgradeable Proxy bu süreci daha kolay ve esnek hale getirir.

Neden Upgradeable Proxy Kullanmalıyız?

Upgradeable Proxy kullanmanın birçok faydası vardır. İşte bazıları:

1. Esneklik: Upgradeable Proxy, smart contract’ların daha esnek hale gelmesini sağlar. Smart contract’ların kendisi değiştirilmeden sadece adresi değiştirilerek yeni bir sürüm devreye alınabilir. Bu sayede, smart contract’ın güncellenmesi daha kolay hale gelir.
2. Maliyet: Smart contract’ların güncellenmesi oldukça maliyetli bir işlemdir. Yeni bir sürüm geliştirmek ve test etmek için zaman ve kaynak gereklidir. Upgradeable Proxy kullanarak, sadece yeni sürümün smart contract adresi değiştirilerek güncelleme işlemi yapılabilir. Bu sayede, yeni sürümü geliştirmek ve test etmek için harcanacak zaman ve kaynak azaltılabilir.
3. Risk Azaltma: Smart contract’ların güncellenmesi riskli bir işlemdir. Yeni bir sürümün hataları, oluşabilecek problemler, güvenlik açıkları gibi pek çok sorun ortaya çıkabilir. Upgradeable Proxy, yeni bir sürümü test ederken, mevcut smart contract’ın adresini korur ve testler tamamlandığında, yeni sürümü eski sürümün yerine geçirir. Bu sayede, smart contract’ların güncellenmesi sırasında daha az risk alınır.
4. Uzun Ömürlülük: Smart contract’ların güncellenmesi, zamanla ortaya çıkan sorunları çözmek için önemlidir. Ancak, bazı projelerde smart contract’ların kullanımı sırasında oluşan verilerin korunması gerekebilir. Upgradeable Proxy kullanarak, smart contract’ın güncellenmesi sırasında bu verilerin korunması sağlanır ve smart contract’ın ömrü uzatılabilir.

Bu nedenlerden dolayı, Upgradeable Proxy kullanarak smart contract’ların güncellenmesi daha esnek, daha ucuz, daha az riskli ve daha uzun ömürlü hale gelir.

Upgradeable Proxy’nin Avantajları ve Dezavantajları Nelerdir?

Upgradeable Proxy kullanmanın birçok avantajı olduğu gibi, dezavantajları da vardır. İşte bazıları:

Avantajlar:

1. Esneklik: Upgradeable Proxy kullanarak smart contract’ların daha esnek hale gelmesini sağlayabilirsiniz. Yeni bir sürümü test etmek ve uygulamak, mevcut smart contract’ın kendisinde herhangi bir değişiklik yapmadan gerçekleştirilebilir.
2. Maliyet: Smart contract’ların güncellenmesi oldukça maliyetli bir işlemdir. Yeni bir sürümü geliştirmek ve test etmek için zaman ve kaynak gereklidir. Upgradeable Proxy kullanarak, sadece yeni sürümün smart contract adresi değiştirilerek güncelleme işlemi yapılabilir. Bu sayede, yeni sürümü geliştirmek ve test etmek için harcanacak zaman ve kaynak azaltılabilir.
3. Güvenlik: Upgradeable Proxy kullanarak, smart contract’ların güncellenmesi sırasında daha az risk alınır. Yeni bir sürümü test ederken, mevcut smart contract’ın adresi korunur ve testler tamamlandığında, yeni sürümü eski sürümün yerine geçirilir.
4. Uzun Ömürlülük: Smart contract’ların güncellenmesi, zamanla ortaya çıkan sorunları çözmek için önemlidir. Ancak, bazı projelerde smart contract’ların kullanımı sırasında oluşan verilerin korunması gerekebilir. Upgradeable Proxy kullanarak, smart contract’ın güncellenmesi sırasında bu verilerin korunması sağlanır ve smart contract’ın ömrü uzatılabilir.

Dezavantajlar:

1. Karmaşıklık: Upgradeable Proxy kullanmak, smart contract’ların geliştirilmesi ve test edilmesi sırasında ekstra bir katman getirir. Bu nedenle, smart contract’ların daha karmaşık hale gelmesi ve daha fazla kaynak gerektirmesi mümkündür.
2. Yeni riskler: Upgradeable Proxy kullanarak smart contract’ların güncellenmesi, yeni güvenlik riskleri oluşturabilir. Yeni sürümün hataları, oluşabilecek problemler, güvenlik açıkları gibi pek çok sorun ortaya çıkabilir.
3. Geriye Dönük Uyumsuzluk: Upgradeable Proxy’nin kullanılması, smart contract’ların geriye dönük uyumsuzluğuna neden olabilir. Eski sürüm ile yeni sürüm arasında değişiklikler olduğunda, kullanıcıların bu değişiklikleri uygulamak için ek adımlar atmaları gerekebilir.

Bu nedenlerden dolayı, Upgradeable Proxy kullanmanın birçok avantajı vardır, ancak bazı dezavantajları da olabilir. Projenizin ihtiyaçlarına ve gereksinimlerine bağlı olarak, Upgradeable Proxy kullanımı sizin için uygun olabilir veya olmayabilir.

Upgradeable Proxy Nasıl Çalışır?

Upgradeable Proxy, smart contract’ların güncellenmesi sırasında eski smart contract’ın yerine yeni bir smart contract oluşturulmasını sağlayan bir mekanizmadır. Bu, smart contract’ın adresinin değiştirilmesiyle yapılır. Böylece, eski smart contract’ın mevcut fonksiyonları değiştirilmeden veya silinmeden, yeni bir sürümünü uygulamak mümkündür.

Upgradeable Proxy, genellikle iki ana bileşenden oluşur:

1. Implementation Contract: Implementation contract, asıl smart contract’ın kodunu içeren bir akıllı sözleşmedir. Bu smart contract, belirli bir mantık ve işlevselliğe sahip olacak şekilde tasarlanır ve geliştirilir.
2. Proxy Contract: Proxy contract, Implementation contract’ın bir ön yüzüdür. Bu smart contract, Implementation contract’a işlevsellik ekleyen, ancak orijinal kodu değiştirmeyen bir arayüz sağlar. Proxy contract, Implementation contract’ın fonksiyonlarının bir listesini içerir ve her bir fonksiyon çağrıldığında, ilgili fonksiyonun Implementation contract’ta çalıştırılmasını sağlar.

Upgradeable Proxy’nin çalışma süreci şu şekildedir:

1. Implementation Contract, geliştirilir ve test edilir.
2. Yeni bir sürüm oluşturulur ve test edilir.
3. Proxy Contract, yeni sürüme bağlanacak şekilde güncellenir.
4. Smart contract’ın kullanıcısı, Proxy Contract aracılığıyla yeni sürümün fonksiyonlarını kullanabilir.

Bu süreçte, Implementation contract’ta herhangi bir değişiklik yapmak gerekmez. Bu, smart contract’ın işlevselliğinin korunmasını ve kullanıcı verilerinin değişmeden kalmasını sağlar. Bunun yerine, Proxy Contract güncellenir ve yeni sürümün fonksiyonlarına erişim sağlanır.

Özetle, Upgradeable Proxy, smart contract’ların esnek ve güvenli bir şekilde güncellenmesini sağlar. Bu, mevcut fonksiyonları korurken yeni özellikler eklemenize ve hataları gidermenize olanak tanır. Bu nedenle, Upgradeable Proxy, özellikle büyük ve uzun ömürlü projeler için faydalı bir mekanizmadır.

Upgradeable Proxy’nin Kullanımı için En İyi Uygulama Senaryoları Nelerdir?

Upgradeable Proxy, smart contract’ların güvenli bir şekilde güncellenmesine olanak sağladığından, birçok farklı kullanım senaryosunda yararlı olabilir. Bazı en iyi uygulama senaryoları şunlardır:

1. DeFi Protokolleri: DeFi protokolleri, genellikle birçok smart contract’tan oluşan karmaşık sistemlerdir. Bu smart contract’ların güncellenmesi sırasında, kullanıcıların fonları ve verileri risk altında olabilir. Upgradeable Proxy, DeFi protokolleri için ideal bir çözüm olabilir, çünkü eski smart contract’lar yerine yeni sürümleri güvenli bir şekilde uygulayabilir.
2. NFT Piyasaları: Non-Fungible Token (NFT) piyasaları, genellikle birkaç smart contract kullanır ve bu smart contract’ların güncellenmesi gerekebilir. Upgradeable Proxy, NFT piyasalarında eski smart contract’ların yerine yeni sürümlerinin güvenli bir şekilde uygulanmasına yardımcı olabilir.
3. Merkeziyetsiz Uygulamalar (DApps): Merkeziyetsiz uygulamalar, birçok smart contract’tan oluşan karmaşık sistemlerdir. Bu smart contract’ların güncellenmesi sırasında, kullanıcıların fonları ve verileri risk altında olabilir. Upgradeable Proxy, DApps’lerdeki smart contract’ların güvenli bir şekilde güncellenmesine yardımcı olabilir.
4. Akıllı Sözleşme Geliştirme: Akıllı sözleşme geliştirme sırasında, kodun düzenli olarak güncellenmesi gerekebilir. Upgradeable Proxy, akıllı sözleşme geliştiricilerinin smart contract’ları güvenli bir şekilde güncellemelerine yardımcı olabilir.
5. Token’lar: Token’lar, genellikle bir smart contract kullanır ve bu smart contract’ların güncellenmesi gerekebilir. Upgradeable Proxy, token’ların güvenli bir şekilde güncellenmesine yardımcı olabilir.

Upgradeable Proxy, birçok farklı kullanım senaryosunda yararlı olabilecek esnek bir mekanizmadır. Ancak, kullanım senaryoları arasında bazı farklılıklar olabilir ve her bir senaryo için özel bir çözüm tasarlamak gerekebilir.

Upgradeable Proxy’nin Dikkat Edilmesi Gereken Güvenlik Riskleri Nelerdir?

Upgradeable Proxy kullanırken dikkat edilmesi gereken bazı güvenlik riskleri vardır:

1. Yürütme Sırasında Hata: Upgradeable Proxy, smart contract’ların güncellenmesi için kod yürütme sırasında kullanılır. Bu nedenle, kodun yürütülmesi sırasında bir hata oluşabilir ve bu da smart contract’ın güncellenmesinin başarısız olmasına neden olabilir.
2. Kimlik Doğrulama Riski: Upgradeable Proxy, smart contract’ın kimlik doğrulamasının yapılmasında kullanılır. Ancak, kimlik doğrulama sürecinde hata yapılması, kimlik avı gibi saldırılara neden olabilir.
3. İşlem Yönetimi Hatası: Upgradeable Proxy, smart contract’ın işlem yönetiminde kullanılır. Ancak, işlem yönetiminde hata yapılması, transferlerin hatalı bir şekilde gerçekleşmesine ve kaynakların çalınmasına neden olabilir.
4. Güvenlik Açıkları: Smart contract’ların güvenlik açıkları vardır ve bu açıklar, Upgradeable Proxy’nin kullanılması sırasında da ortaya çıkabilir. Bu nedenle, smart contract’lar ve Upgradeable Proxy dikkatle test edilmeli ve güvenlik açıklarından kaçınılmalıdır.
5. Upgradeable Proxy’de Zayıf Yönler: Upgradeable Proxy’nin kendisi de güvenlik açıklarına neden olabilecek zayıf yönleri vardır. Bu nedenle, Upgradeable Proxy kullanmadan önce, proxy’lerin güvenlik açıkları hakkında bilgi sahibi olmak önemlidir.

Bu nedenlerden dolayı, Upgradeable Proxy kullanırken dikkatli olmak ve güvenlik risklerini minimize etmek için güvenlik testleri yapmak önemlidir. Ayrıca, Upgradeable Proxy kullanmadan önce iyi bir planlama yapmak ve özel senaryolar için uygun bir çözüm tasarlamak da önemlidir.

Upgradeable Proxy’nin Solidity’de Nasıl Uygulanacağına Dair Adım Adım Kılavuz

Upgradeable Proxy, Solidity’de uygulanabilen bir tasarım desenidir. Aşağıdaki adımları takip ederek Upgradeable Proxy tasarımını Solidity’de uygulayabilirsiniz:

1. İlk olarak, BaseContract adında bir smart contract oluşturun. Bu, smart contract’ın temel işlevlerini içeren bir kontrattır. Bu smart contract, Upgradeable Proxy için temel olarak kullanılacak olan smart contract’tır.
2. Ardından, Upgradeable adında bir smart contract oluşturun. Bu, BaseContract ile birlikte kullanılacak bir kontrattır. Upgradeable, smart contract’ın güncellenmesi için kullanılacaktır.
3. Upgradeable Proxy’yi oluşturmak için Proxy adında bir smart contract daha oluşturun. Bu, Upgradeable ve BaseContract’ı birleştiren smart contract’tır.
4. BaseContract’ın fonksiyonları Proxy kontratına yönlenir ve orada çağrılır. Proxy, çağrılan fonksiyonu Upgradeable smart contract’ına aktarır. Bu şekilde, Upgradeable Proxy BaseContract’ın fonksiyonlarına erişebilir ve onları güncelleyebilir.
5. Güncelleme yapmak için Upgradeable smart contract’ına yeni bir versiyon ekleyin. Bu yeni versiyon, BaseContract ile uyumlu olmalıdır. Daha sonra, Proxy kontratında Upgradeable smart contract’ının adresini değiştirerek güncelleyin.
6. Güncellemenin gerçekleştiğinden emin olmak için Upgradeable Proxy’yi test edin ve güvenlik açıkları olup olmadığını kontrol edin.

Bu adımları takip ederek, Solidity’de Upgradeable Proxy tasarımını uygulayabilirsiniz. Ancak, bu konuda tecrübesizseniz, öncelikle Solidity hakkında daha fazla bilgi edinmeniz ve Upgradeable Proxy’yi uygulamadan önce iyi bir planlama yapmanız önerilir.

Örneklem İncelemesi

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

// Transparent upgradeable proxy pattern

contract CounterV1 {
    uint public count;

    function inc() external {
        count += 1;
    }
}

contract CounterV2 {
    uint public count;

    function inc() external {
        count += 1;
    }

    function dec() external {
        count -= 1;
    }
}

contract BuggyProxy {
    address public implementation;
    address public admin;

    constructor() {
        admin = msg.sender;
    }

    function _delegate() private {
        (bool ok, bytes memory res) = implementation.delegatecall(msg.data);
        require(ok, "delegatecall failed");
    }

    fallback() external payable {
        _delegate();
    }

    receive() external payable {
        _delegate();
    }

    function upgradeTo(address _implementation) external {
        require(msg.sender == admin, "not authorized");
        implementation = _implementation;
    }
}

contract Dev {
    function selectors() external view returns (bytes4, bytes4, bytes4) {
        return (
            Proxy.admin.selector,
            Proxy.implementation.selector,
            Proxy.upgradeTo.selector
        );
    }
}

contract Proxy {
    // All functions / variables should be private, forward all calls to fallback

    // -1 for unknown preimage
    // 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc
    bytes32 private constant IMPLEMENTATION_SLOT =
        bytes32(uint(keccak256("eip1967.proxy.implementation")) - 1);
    // 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103
    bytes32 private constant ADMIN_SLOT =
        bytes32(uint(keccak256("eip1967.proxy.admin")) - 1);

    constructor() {
        _setAdmin(msg.sender);
    }

    modifier ifAdmin() {
        if (msg.sender == _getAdmin()) {
            _;
        } else {
            _fallback();
        }
    }

    function _getAdmin() private view returns (address) {
        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;
    }

    function _setAdmin(address _admin) private {
        require(_admin != address(0), "admin = zero address");
        StorageSlot.getAddressSlot(ADMIN_SLOT).value = _admin;
    }

    function _getImplementation() private view returns (address) {
        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;
    }

    function _setImplementation(address _implementation) private {
        require(_implementation.code.length > 0, "implementation is not contract");
        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = _implementation;
    }

    // Admin interface //
    function changeAdmin(address _admin) external ifAdmin {
        _setAdmin(_admin);
    }

    // 0x3659cfe6
    function upgradeTo(address _implementation) external ifAdmin {
        _setImplementation(_implementation);
    }

    // 0xf851a440
    function admin() external ifAdmin returns (address) {
        return _getAdmin();
    }

    // 0x5c60da1b
    function implementation() external ifAdmin returns (address) {
        return _getImplementation();
    }

    // User interface //
    function _delegate(address _implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.

            // calldatacopy(t, f, s) - copy s bytes from calldata at position f to mem at position t
            // calldatasize() - size of call data in bytes
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.

            // delegatecall(g, a, in, insize, out, outsize) -
            // - call contract at address a
            // - with input mem[in…(in+insize))
            // - providing g gas
            // - and output area mem[out…(out+outsize))
            // - returning 0 on error (eg. out of gas) and 1 on success
            let result := delegatecall(gas(), _implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            // returndatacopy(t, f, s) - copy s bytes from returndata at position f to mem at position t
            // returndatasize() - size of the last returndata
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                // revert(p, s) - end execution, revert state changes, return data mem[p…(p+s))
                revert(0, returndatasize())
            }
            default {
                // return(p, s) - end execution, return data mem[p…(p+s))
                return(0, returndatasize())
            }
        }
    }

    function _fallback() private {
        _delegate(_getImplementation());
    }

    fallback() external payable {
        _fallback();
    }

    receive() external payable {
        _fallback();
    }
}

contract ProxyAdmin {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

    function getProxyAdmin(address proxy) external view returns (address) {
        (bool ok, bytes memory res) = proxy.staticcall(abi.encodeCall(Proxy.admin, ()));
        require(ok, "call failed");
        return abi.decode(res, (address));
    }

    function getProxyImplementation(address proxy) external view returns (address) {
        (bool ok, bytes memory res) = proxy.staticcall(
            abi.encodeCall(Proxy.implementation, ())
        );
        require(ok, "call failed");
        return abi.decode(res, (address));
    }

    function changeProxyAdmin(address payable proxy, address admin) external onlyOwner {
        Proxy(proxy).changeAdmin(admin);
    }

    function upgrade(address payable proxy, address implementation) external onlyOwner {
        Proxy(proxy).upgradeTo(implementation);
    }
}

library StorageSlot {
    struct AddressSlot {
        address value;
    }

    function getAddressSlot(
        bytes32 slot
    ) internal pure returns (AddressSlot storage r) {
        assembly {
            r.slot := slot
        }
    }
}

contract TestSlot {
    bytes32 public constant slot = keccak256("TEST_SLOT");

    function getSlot() external view returns (address) {
        return StorageSlot.getAddressSlot(slot).value;
    }

    function writeSlot(address _addr) external {
        StorageSlot.getAddressSlot(slot).value = _addr;
    }
}

Bu sözleşme, Ethereum blok zincirinde çalıştırılabilir. Kod, “CounterV1” ve “CounterV2” adlı iki sözleşmeyle başlar. “CounterV1” sözleşmesi, “count” değişkenini bir artırma işlevine sahiptir. “CounterV2” sözleşmesi, “count” değişkenini bir artırma ve bir azaltma işlevine sahiptir. “BuggyProxy” adlı bir sözleşme, yönetici (admin) adresi tarafından yapılan çağrılarda işlevsellik sağlar. Bu sözleşme, belirli bir adrese işlevsellik sunmak için yönlendirme yapabilen bir “Proxy” sözleşmesini kullanır. “Proxy” sözleşmesi, kullanıcı arabirimi (user interface) ve yönetici arabirimi (admin interface) içerir. Yönetici arabiriminde, yöneticinin “changeAdmin” işlevi aracılığıyla yönetici adresi değiştirilebilir. “upgradeTo” işlevi aracılığıyla “Proxy” sözleşmesinin belirli bir adrese güncellenmesi sağlanabilir. “admin” ve “implementation” işlevleri, yöneticinin adresini ve mevcut uygulama adresini döndürür. Bu işlevler, yalnızca yönetici adresinden yapılan çağrılarda erişilebilir hale getirilmiştir.

Sonuç Bağlamı

Bu akıllı sözleşme örneği “Transparent Upgradeable Proxy” adı verilen bir deseni kullanarak Solidity dilinde yazılmıştır. Bu desen, akıllı sözleşmelerde değişiklik yapmanın ve sözleşmenin uygulamasını güncellemenin yollarını sağlar.

Bu sözleşme, iki sürümü olan bir sayaç uygulaması içerir: CounterV1 ve CounterV2. İlk sürüm yalnızca bir artırma işlevi içerirken, ikinci sürüm artırma işlevinin yanı sıra bir azaltma işlevi de içerir.

Proxy kontratı, depolama yoluyla bir uygulama adresi yönetir ve ayrıca yöneticiyi de tanımlar. BuggyProxy kontratı, yöneticinin uygulamayı güncellemesine izin veren bir arayüz sağlar.

Dev kontratı, proxy’nin yönetici ve uygulama yöntem seçicilerini döndürür.

Proxy kontratı, tüm işlevleri ve değişkenleri özel olarak tanımlar ve tüm çağrıları fallback işlevine yönlendirir. Bu, akıllı sözleşmenin uygulama ayrıntılarını gizli tutarak, yönetici için yönetim arayüzü sağlar.

Solidity Programlama Dili Öğrenme yolculuğunuz hakkında daha iyi rehberlik almak için Solidity nedir? Ethereum Akıllı Sözleşmelerinin Dili Rehberi içeriğimize göz atın. Dilerseniz Yeni Başlayanlar için Solidity – Akıllı Sözleşme Geliştirme Hızlandırılmış Kursuna katılın.

Çalışmaya nereden başlayacağım diyenler için Blockchain ​​Developer Olmak İçin Yol Haritası içeriğine de muhakkak bakın.

Gelin aklınızdaki soruları SUPERPEER sohbetinde cevaplayalım.

Bu makaleyi okuduğunuz için teşekkürler! Bana destek olmak isterseniz;

Beni Twitter, Linkedin ve YouTube‘da takip edin.

Kısa bir yorum bırakmayı UNUTMAYIN!