Deno Uygulaması Nasıl Dağıtılır?

Deno ile oluşturulmuş web uygulamaları için çeşitli dağıtım seçenekleri mevcuttur. Ancak, bir hizmet platformu olarak konteynerizasyon, diğer dağıtım seçeneklerine göre sundukları çeşitli avantajlar nedeniyle son zamanlarda popüler bir seçim haline geldi.

Bu makalede Deno’yu, avantajlarını ve sınırlamalarını keşfedeceksiniz. Ayrıca, basit bir Deno uygulaması oluşturacak ve Back4app konteynerlerine dağıtacaksınız.

Deno nedir?

Deno, Node.js’de bulunan sınırlamaları ve tasarım kusurlarını gidermek için oluşturulan JavaScript ve TypeScript için güvenli ve modern bir çalışma zamanıdır.

Node.js’den farklı olarak, dosya sistemi ve ağ erişimi için ayrıntılı izinler uygulayarak varsayılan olarak güvenliği vurgular.

Ayrıca Deno, TypeScript’i yerel olarak destekleyerek diğer özelliklerinin yanı sıra ek kurulum veya transpilasyon adımlarına olan ihtiyacı ortadan kaldırır.

Deno, 2018’de piyasaya sürüldüğünden bu yana Node.js üzerindeki iyileştirmeleri nedeniyle geliştiricilerin dikkatini ve ilgisini çekti.

Bununla birlikte, Deno iyileştirmeler sunarken, Node.js kapsamlı topluluk desteği ve geniş bir paket deposu ile olgun bir ekosistem olmaya devam etmektedir.

Bununla birlikte Deno, yaklaşımını takdir eden ve potansiyelini keşfeden, giderek büyüyen bir geliştirici topluluğunun ilgisini çekmiştir.

Deno’nun Avantajları

Deno’nun popülerlik kazanmasının altında yatan bazı nedenler var. Bazıları aşağıdaki gibidir.

Node.js’ye Göre Geliştirilmiş Güvenlik

Deno, izin tabanlı bir güvenlik modeli uygulayarak ve uygulamaları sandbox ortamında çalıştırarak önemli bir avantaj olarak gelişmiş güvenlik sunar.

Dosya sistemi ve ağ gibi kaynaklara erişim için açık yetkilendirmenin gerekli olduğu izin tabanlı bir güvenlik modeli uygular.

Varsayılan olarak, Deno kısıtlı bir modda çalışır ve uygulamaları korumalı bir ortamda çalıştırarak potansiyel olarak riskli eylemleri sınırlandırır, bunları temel sistemden izole eder ve hassas kaynaklara doğrudan erişimi önler.

Kapsamlı güvenlik denetimleri ve titiz kod incelemeleri Deno’nun sağlam güvenliğini daha da güçlendirir. Bu önlemler, uygulamalar oluşturmak, güvenliklerine güven aşılamak ve olası güvenlik açıklarına karşı korumak için güvenilir ve güvenli bir platform sağlar.

Bağımlılık Yönetimi

Deno, Node.js gibi geleneksel JavaScript çalışma zamanı ortamlarına kıyasla bağımlılık yönetimine farklı bir yaklaşım sunar.

Deno, merkezi bir paket kayıt defterine güvenmek yerine, modülleri doğrudan web’den içe aktarmak için URL’leri kullanır.

Bu yaklaşım, npm gibi ayrı bir paket yöneticisine olan ihtiyacı ortadan kaldırarak ve sürüm çakışmaları ve “node_modules” klasörünü yönetmenin karmaşıklığı ile ilgili endişeleri azaltarak süreci basitleştirir.

İçe aktarmak istedikleri modüllerin URL’lerini belirterek bağımlılıkları belirleyebilir, böylece kod paylaşımını ve dağıtımını kolaylaştırabilirsiniz. Deno’daki bağımlılık yönetimine yönelik bu merkezi olmayan yaklaşım, basitliği teşvik eder, sürtünmeyi azaltır ve daha akıcı bir geliştirme deneyimi sağlamaya yardımcı olur.

Kutudan Çıkar çıkmaz TypeScript Desteği

Deno, TypeScript için yerel ve sorunsuz destek sunar, bu da projelerinizde TypeScript’i tercih ediyorsanız veya gerektiriyorsa mükemmel bir seçimdir.

TypeScript, JavaScript geliştirmeye statik yazım ve diğer gelişmiş dil özelliklerini getiren JavaScript’in tiplendirilmiş bir üst kümesidir. Deno ile TypeScript’i kullanmak için ek yapılandırma veya derleme adımlarına gerek yoktur.

Deno, TypeScript derleyicisi ile birlikte gelir ve TypeScript kodunu doğrudan yazmanıza ve çalıştırmanıza olanak tanır.

Bu yerel destek, ayrı bir TypeScript araç zinciri kurmanın karmaşıklığını ortadan kaldırır ve geliştirme sürecini basitleştirir.

Deno ile uygulama geliştirirken TypeScript’in tür denetiminden, gelişmiş araçlarından ve gelişmiş geliştirici deneyiminden yararlanmanızı sağlar.

Deno’nun Sınırlamaları

Bununla birlikte, Deno’nun benimsenmesini etkileyen bazı sınırlamaları vardır. Bunlardan bazıları aşağıdaki gibidir.

Olgunlaşmamış Ekosistem

Deno’nun sınırlamalarından biri de ekosisteminin olgunluğudur. Daha uzun süredir var olan Node.js ile karşılaştırıldığında, Deno’nun ekosistemi hala nispeten yeni ve gelişmekte.

Bu, Deno için özel olarak tasarlanmış daha az üçüncü taraf kütüphanesi, çerçevesi ve aracı olabileceği anlamına gelir. Belirli işlevleri sıfırdan oluşturmanız veya mevcut Node.js paketlerini Deno’da kullanmak için uyarlamanız gerekebilir.

Daha küçük topluluk boyutu, köklü Node.js ekosistemine kıyasla daha az kaynak, eğitim ve topluluk desteğinin mevcut olabileceği anlamına da gelir.

Bununla birlikte, Deno popülerlik kazandıkça ve benimsendikçe, ekosisteminin büyümesi ve olgunlaşması ve gelecekte daha geniş bir kütüphane ve araç yelpazesi sunması beklenmektedir.

Dik Öğrenme Eğrisi

Deno’nun bir başka sınırlaması da Node.js gibi diğer JavaScript çalışma zamanı ortamlarından geçişle ilgili öğrenme eğrisidir.

Deno, kendinizi tanımanız gerekebilecek yeni kavramlar, API’ler ve modeller sunar. Bu, Deno’nun modül sistemini, izin tabanlı güvenlik modelini ve belirli işlevlerin diğer çalışma zamanlarına kıyasla nasıl uygulandığındaki farklılıkları anlamayı içerir.

Node.js’de zaten yetkin olan geliştiricilerin Deno’nun belirli özelliklerini ve kurallarını öğrenmek ve bunlara uyum sağlamak için zaman ve çaba harcaması gerekebilir.

Bununla birlikte, resmi Deno belgelerine başvurarak, Deno topluluğuyla etkileşime girerek ve mevcut öğrenme kaynaklarını keşfederek öğrenme eğrisi yönetilebilir.

Node.js Kütüphaneleri ile Uyumluluk

Node.js kütüphaneleri ile uyumluluk Deno’nun bir başka sınırlamasıdır. Modül sistemleri ve çalışma zamanı ortamlarındaki farklılıklar nedeniyle, tüm Node.js kütüphaneleri ve modülleri değişiklik yapılmadan doğrudan Deno’da kullanılamaz.

Deno, modül sistemi olarak ES modüllerini (ECMAScript modülleri) kullanırken, Node.js geleneksel olarak CommonJS modüllerini kullanır. Modül formatlarındaki bu farklılık, Deno’da Node.js’ye özgü modülleri içe aktarırken ve kullanırken uyumsuzluklara yol açabilir.

Geliştiricilerin ayarlamalar yapması veya Deno’nun modül sistemiyle çalışmak üzere özel olarak tasarlanmış alternatif kütüphaneler bulması gerekebilir.

Deno, bazı Node.js modüllerini çalıştırmak için bir uyumluluk katmanı sağlasa da, tüm durumları kapsamayabilir ve manuel değişiklikler veya uyarlamalar gerekebilir.

Deno Dağıtım Seçenekleri

Deno uygulamaları için çeşitli dağıtım seçenekleri vardır ve bunlardan bazıları aşağıdakileri içerir.

Hizmet Olarak Altyapı (IaaS)

Hizmet olarak altyapı (IaaS), sanallaştırılmış bilgi işlem kaynakları sunan bir bulut bilişim modelidir. IaaS ile bulut sağlayıcılarından kullandığın kadar öde temelinde sanal makineler, depolama ve ağ kiralayabilirsiniz. Bu, fiziksel donanıma yatırım yapmadan kendi sanallaştırılmış altyapınızı kurmanıza ve yönetmenize olanak tanır.

IaaS seçenekleri, Deno uygulamalarını sanal makinelerde çalıştırmanıza olanak tanır. AWS, Google Cloud ve Microsoft Azure gibi popüler IaaS platformları, esnek ve ölçeklenebilir çözümler sunarak altyapıyı uygulamanızın özel ihtiyaçlarına göre yapılandırmanıza olanak tanır.

Bununla birlikte, IaaS size daha fazla kontrol ve kaynak izolasyonu sağlarken, sunucu sağlama, güvenlik güncellemeleri ve izleme gibi görevleri içeren daha fazla manuel kurulum ve yönetim de gerektirir.

Bu nedenle IaaS, altyapınız üzerinde kapsamlı kontrole ihtiyaç duyduğunuzda ve karmaşıklıklarını etkili bir şekilde ele almak için uzmanlığa sahip olduğunuzda uygun bir seçimdir.

Hizmet Olarak Konteyner (CaaS)

Container-as-a-Service (CaaS), konteynerleştirilmiş uygulamaların dağıtımını ve yönetimini basitleştiren bir bulut bilişim modelidir.

CaaS ile, altta yatan altyapı hakkında endişelenmeden uygulama oluşturmaya ve dağıtmaya odaklanabilirsiniz.

Deno uygulamaları, tutarlılık ve izolasyon sağlayan konteynerler içinde dağıtılabilir. Back4app konteynerleri, Deno dağıtımı için popüler bir CaaS seçeneğidir.

CaaS platformları, her uygulamanın kendi konteynerinde çalışmasıyla ölçeklenebilirlik ve kaynak izolasyonu sunarak güvenliği ve istikrarı artırır.

Konteynerlerin tutarlılığı, Deno uygulamalarının konteynerleri destekleyen herhangi bir platformda kolayca dağıtılabilmesini sağlar.

CaaS çözümlerinin bir öğrenme eğrisi olsa da, birden fazla düğüm veya küme arasında dinamik ölçeklendirme ve dağıtım gerektiren uygulamalar için önemli faydalar sağlarlar.

Deno Kurulum Süreci

Deno’yu kullanabilmeniz için önce indirmeniz ve kurmanız gerekir. Deno’nun kurulumu işletim sisteminize bağlı olarak değişir.

MacOS ve Linux’ta Deno’yu aşağıdaki komutu çalıştırarak yükleyebilirsiniz:

curl -fsSL <https://deno.land/x/install/install.sh> | sh

Windows’ta, aşağıdaki komutu çalıştırarak Powershell kullanarak Deno’yu yükleyebilirsiniz:

irm <https://deno.land/install.ps1> | iex

Kurulumunuzun başarılı olduğunu doğrulamak için aşağıdaki komutu çalıştırabilirsiniz ve terminalinize bir sürüm numarası yazdırmalıdır.

deno --version

Sürüm numarasını göremiyorsanız, Deno’yu tekrar yüklemeyi deneyin.

Bir Deno Projesi Kurma

Deno ile basit bir API oluşturmak için bir yönlendiriciye, bir sunucuya ve bir veritabanına ihtiyacınız olacaktır.

Aşağıdaki adımları izlemeden önce, projenizin kök dizininde bir src klasörü oluşturun. Bu klasör projenizin tüm kaynak dosyalarını içerecektir.

Adım 1: Bağımlılık Dosyası Oluşturma

Node.js’den farklı olarak Deno, NPM veya Yarn gibi paket yöneticileri kullanır. Bunun yerine, paketler doğrudan URL’lerinden içe aktarılır.

Bir package.json dosyasının işlevlerini taklit etmek için, projenizin kök dizininde bir deps.ts dosyası oluşturun ve aşağıdaki kod bloğunu bu dosyaya ekleyin.

export { Application, Router } from "https://deno.land/x/[email protected]/mod.ts";
export type { RouterContext} from "https://deno.land/x/[email protected]/mod.ts";
export { config as dotenvConfig } from "https://deno.land/x/[email protected]/mod.ts";
export { Client } from "https://deno.land/x/[email protected]/mod.ts";

Yukarıdaki kod bloğu Oak’tan Application, Router ve RouterContex ‘i içe aktarır (yükler) ve dışa aktarır. dotenv’den config ve deno-postgres’ten Client.

Adım 2: Bir Sunucu Oluşturma

Bu adım için Oak ile basit bir HTTP sunucusu oluşturacaksınız. Oak, Deno’nun HTTP sunucusu için Express’e benzer ancak daha hafif bir Node.js çerçevesi olan Koa.js tabanlı bir ara yazılımdır.

Oak ile bir HTTP sunucusu oluşturmak için src dosyanızda bir server.ts dosyası oluşturun ve aşağıdaki kod bloğunu buna ekleyin.

import { Application } from "../deps.ts";
import config from "../config/default.ts";

import router from "./router.ts";

const app = new Application();

app.use(router.routes());
app.use(router.allowedMethods());

await app.listen({ port: config.port });

Yukarıdaki kod bloğu Oak ile bir HTTP sunucusu oluşturur ve gelen tüm trafiği işlemek için bir yönlendirici kaydeder.

app.use(router.routes()) satırı, yönlendiricinin rotalarını Oak uygulamasında ara katman olarak kaydeder. Gelen tüm istekler kayıtlı rotalarla eşleştirilecek ve bir eşleşme bulunursa ilgili işleyiciler yürütülecektir.

Bir eşleşme bulunamazsa, app.use(router.allowedMethods()) satırı 404 not found veya 405 not allowed gibi uygun yanıtlar göndererek bunları ele alır.

Adım 3: Çevresel Değişkenlerin Yönetilmesi

API Anahtarları, Veritabanı kimlik bilgileri gibi hassas verilerin düz metin olarak saklanması güvenlik riski oluşturur. Anahtarlarınızı veya kimlik bilgilerinizi ele geçiren herkes uygulamanıza sınırsız erişime sahip olabilir. Bu durum, diğer olası istismarların yanı sıra veri kaybına ve veri hırsızlığına neden olabilir.

Bu gibi durumlardan kaçınmak için hassas verilerin çevresel değişkenlerde saklanması iyi bir uygulama olarak kabul edilir.

Projenizin kök klasöründe bir .env dosyası oluşturun ve veritabanı kimlik bilgilerinizi ve diğer hassas bilgileri bu dosyada saklayın.

Bu şekilde:

#.env
DB_URI = <YOUR_POSTGRES_DB_URI>
PORT = 8000

adresini veritabanı kimlik bilgilerinizle değiştirin.

Ardından, projenizin kök klasöründe bir config klasörü oluşturun ve config klasöründe bir default.ts dosyası oluşturup aşağıdaki kod bloğunu buna ekleyin.

//default.ts
import { dotenvConfig } from "../deps.ts";

dotenvConfig({
  export: true,
  path: "../.env",
});

const config = {
  db: {
    dbUri: Deno.env.get("DB_URI"),
  },
  port: 3000
};

export default config;

Yukarıdaki kod bloğu, .env dosyanızda depolanan değerleri güvenli bir şekilde alır ve uygulamanızın geri kalanına sunar.

Adım 3: Bir Veritabanına Bağlanma

Bu adım için uygulamanızı bir Postgres veritabanına bağlayacaksınız. Uygulamanız için veri depolamak ve almak için veritabanına ihtiyacınız olacak.

src klasörünüzde bir db.ts dosyası oluşturun ve aşağıdaki kod bloğunu buna ekleyin.

//db.ts
import { Client } from "../deps.ts";
import config from "../config/default.ts";

let postgresConfiguration = config.db.dbUri;

const client = new Client(postgresConfiguration);

await client.connect();

export default client;

Yukarıdaki kod bloğu, .env dosyanızda sağladığınız URI’yi kullanarak uygulamanızı bir Postgres veritabanına bağlamaya çalışır.

Adım 4: Veritabanı Deposu Oluşturma

src klasörünüzde bir blogRepository dosyası oluşturun ve aşağıdaki kodu dosyanıza ekleyin.

//blogRepository.ts
import client from "./db.ts";

class BlogRepository {
  async createBlogTable() {
    const blog = await client.queryArray(
      `CREATE TABLE IF NOT EXISTS blogs (id SERIAL PRIMARY KEY, title VARCHAR(255), body VARCHAR(255), author VARCHAR(255))`
    );

    return blog;
  }

  async getAllBlogs() {
    const allBlogs = await client.queryArray("SELECT * FROM blogs");

    return allBlogs;
  }

  async getBlogById(id: string) {
    const blog = await client.queryArray(
      `SELECT * FROM blogs WHERE id = ${id}`
    );

    return blog;
  }

  async createBlog(title: string, body: string, author: string) {
    const blog = await client.queryArray(
      `INSERT INTO blogs (title, body, author) VALUES ('${title}', '${body}', '${author}')`
    );

    return blog;
  }

  async updateBlog(id: string, title: string, body: string, author: string) {
    const blog = await client.queryArray(
      `UPDATE blogs SET title = '${title}', body = '${body}', author = '${author}' WHERE id = ${id}`
    );

    return blog;
  }

  async deleteBlog(id: string) {
    const blog = await client.queryArray(`DELETE FROM blogs WHERE id = ${id}`);

    return blog;
  }
}

export default new BlogRepository();

Yukarıdaki kod bloğu, ham SQL sorgularını soyutlayarak ve Postgres veritabanınızla etkileşim kurmak için kullanabileceğiniz basit yöntemleri açığa çıkararak tüm veritabanı işlemlerini gerçekleştirecektir.

Adım 5: Rota İşleyicileri Oluşturma

Bu adımda, uygulamanız için basit CRUD işlevlerini işlemek üzere rota işleyicileri oluşturacaksınız. Desteklenen rotalar aşağıdaki gibidir:

• GET /api/blogs: Veritabanınızdaki tüm blogları döndürür
• GET /api/blog/:id: URL parametrelerinde sağlanan eşleşen id’ye sahip tek bir blog döndürür.
• POST /api/blog/new: Veritabanınızda yeni bir blog oluşturur.
• PUT /api/blog/:id: URL parametrelerinde sağlanan eşleşen id ile bir blogu günceller.
• DELETE /api/blog/:id: URL parametrelerinde sağlanan eşleşen id’ye sahip bir blogu siler.

src klasörünüzde bir router.ts dosyası oluşturun ve aşağıdaki içe aktarmaları ekleyin.

import { Router, RouterContext } from "../deps.ts";
import blogRepository from "./blogRepository.ts";

Ardından, aşağıdaki kod bloğunu ekleyerek bir yönlendirici örneği oluşturun:

const router = new Router();

Yönlendirici işleyicilerinizi kaydetmek için onları yönlendirici örneğine zincirlemeniz gerekir.

Örneğin (GET /api/blogs):

router
  .get("/api/blogs", async (ctx: RouterContext<"/api/blogs">) => {
    const data = await blogRepository.getAllBlogs();
    console.log(data);

    //format data
    const allBlogs = data.rows.map((blog) => {
      return {
        id: blog[0],
        title: blog[1],
        body: blog[2],
        author: blog[3]
      };
    });

    ctx.response.body = allBlogs;
  })

Yukarıdaki kod bloğu, işleyici mantığını yönlendirici örneğine zincirleyerek GET /api/blogs için bir rota işleyicisi oluşturur.

Rotaların geri kalanını kaydetmek için bunları önceden zincirlenmiş yönteme zincirleyin. Bunun gibi:

GET /api/blog/:id:

.get("/api/blog/:id", async (ctx: RouterContext<"/api/blog/:id">) => {
    try {
      const data = await blogRepository.getBlogById(ctx.params.id);
      console.log(data);

      //format data
      const blog = data.rows.map((blog) => {
        return {
          id: blog[0],
          title: blog[1],
          body: blog[2],
          author: blog[3]
        };
      });

      ctx.response.body = blog;
    } catch (error) {
      ctx.response.status = 500;
      ctx.response.body = {
        msg: "Error getting blog",
        error,
      };
    }
  })

POST /api/blog/new

.post("/api/blog/new", async (ctx: RouterContext<"/api/blog/new">) => {
    const resBody = ctx.request.body();
    const blog = await resBody.value;

    if (!blog) {
      ctx.response.status = 400;
      ctx.response.body = { msg: "Invalid data. Please provide a valid blog." };
      return;
    }

    const { title, body, author } = blog;

    if (!(title && body && author)) {
      ctx.response.status = 400;
      ctx.response.body = {
        msg: "Title or description missing. Please provide a valid blog.",
      };
      return;
    }

    try {
      await blogRepository.createBlog(title, body, author);

      ctx.response.status = 201;
      ctx.response.body = {
        msg: "blog added successfully",
      };
    } catch (error) {
      ctx.response.status = 500;
      ctx.response.body = {
        msg: "Error adding blog",
        error,
      };
    }
  })

PUT /api/blog/:id:

.put("/api/blog/:id", async (ctx: RouterContext<"/api/blog/:id">) => {
    try {
      const resBody = ctx.request.body();
      const blog = await resBody.value;

      if (!blog) {
        ctx.response.status = 400;
        ctx.response.body = {
          msg: "Invalid data. Please provide a valid blog.",
        };
        return;
      }

      const { title, body, author } = blog;

      if (!(title && body && author)) {
        ctx.response.status = 400;
        ctx.response.body = {
          msg: "Title or description missing. Please provide a valid blog.",
        };

        return;
      }

      await blogRepository.updateBlog(ctx.params.id, title, body, author);

      ctx.response.status = 200;
      ctx.response.body = {
        msg: "blog updated successfully",
      };
    } catch (error) {
      console.log(error);
      ctx.response.status = 500;
      ctx.response.body = {
        msg: "Error updating blog",
        error: error.message,
      };
    }
  })

DELETE /api/blog/:id:

.delete("/api/blog/:id", async (ctx: RouterContext<"/api/blog/:id">) => {
    await blogRepository.deleteBlog(ctx.params.id);

    ctx.response.status = 200;
    ctx.response.body = {
      msg: "blog deleted successfully",
    };
  });

Ardından, yönlendirici örneğinizi dışa aktarın. Bunun gibi:

export default router;

Son olarak, uygulama ilk kez başlatıldığında bir blog veritabanı oluşturmak için server.ts dosyanızı değiştirin.

Bu şekilde:

import { Application } from "../deps.ts";
import config from "../config/default.ts";
import blogRepository from "./blogRepository.ts";

import router from "./router.ts";

const app = new Application();

(async () => {
  await blogRepository.createBlogTable();
})();

app.use(router.routes());
app.use(router.allowedMethods());

await app.listen({ port: config.port });

Değiştirilen kod, server.ts dosyasına veritabanınızda yeni bir blog tablosu oluşturan bir IIFE ekler.

Deno Uygulamanızı Back4app Konteynerlerine Dağıtma

Deno uygulamanızı Back4app konteynerlerine dağıtmak için aşağıdaki adımları izlemeniz gerekir:

Adım 1: Bir Docker dosyası oluşturun

Bir Dockerfile, bir Docker görüntüsü oluşturmak için özel talimatlar sağlar. Bu talimatlar görüntüyü oluşturma sürecine rehberlik eder.

Bir Dockerfile oluşturmak için aşağıdaki komutu çalıştırın:

touch Dockerfile

Yukarıdaki komut, projenizin kök dizininde bir Dockerfile oluşturur.

Ardından, aşağıdaki kod bloğunu Dockerfile’ınıza ekleyin:

FROM denoland/deno:latest

EXPOSE 8000

WORKDIR /app

COPY deps.ts .
RUN deno cache deps.ts

COPY . .

RUN deno cache src/server.ts

CMD ["run", "--allow-net", "--allow-env", "--allow-read", "src/server.ts"]

Yukarıdaki Docker dosyası, bir Deno uygulamasını çalıştırmak için konteynerleştirilmiş bir ortam kurar. Uygulama bağımlılıklarını ve giriş noktasını önbelleğe alır ve ardından konteyner başlatıldığında Deno uygulamasını belirtilen izinlerle çalıştırır.

Uygulamanın 8000 numaralı bağlantı noktasını dinlemesi beklenir, ancak gerçek bağlantı noktası eşlemesi kapsayıcı çalıştırılırken yapılmalıdır.

Son olarak, kodunuzu GitHub‘a gönderin.

Adım 2: Yeni bir Back4app Uygulaması Oluşturun

Bir Back4app uygulaması oluşturmak için resmi Back4app web sitesini ziyaret edin. Oraya vardığınızda, Back4app açılış sayfasının sağ üst köşesindeki Kaydol düğmesini bulun. Kaydol butonuna tıkladığınızda bir kayıt formuna yönlendirileceksiniz. Bu formu e-posta adresiniz, kullanıcı adınız ve şifreniz gibi gerekli ayrıntılarla doldurmaya devam edin. Doğru bilgileri verdiğinizden emin olun. Formu doldurduktan sonra gönderin.

Zaten bir hesabınız varsa, bunun yerine Oturum aç’a tıklayın.

Back4app hesabınızı başarıyla kurduktan sonra, hesap kontrol panelinize erişmek için oturum açın. Buradan, “YENİ UYGULAMA” düğmesini bulun ve üzerine tıklayın.

Bu eylem sizi yeni uygulamanızı oluşturmak için farklı seçeneklerin sunulacağı bir sayfaya yönlendirecektir. Amacınız kapsayıcı kullanarak dağıtım yapmak olduğundan,“Containers as a Service” seçeneğini tercih edin.

Ardından, GitHub hesabınızı Back4app hesabınıza bağlayın. Back4app’e hesabınızdaki tüm depolara veya belirli depolara erişim verebilirsiniz.

Dağıtmak istediğiniz uygulamayı (bu durumda, bu eğitimde oluşturduğunuz uygulamayı) seçin ve Seç‘e tıklayın.

Seç düğmesine tıkladığınızda, uygulamanız hakkında ad, şube, kök dizin, otomatik dağıtım seçenekleri, bağlantı noktası, sağlık durumu ve çevresel değişkenler gibi bazı bilgileri doldurmanız gereken bir sayfaya yönlendirileceksiniz.

Uygulamanızın doğru çalışması için gereken tüm çevresel değişkenleri sağladığınızdan emin olun. Gerekli bilgileri doldurmayı tamamladıktan sonra, ‘Uygulama Oluştur’ düğmesine tıklayın.

Bu, dağıtım sürecini başlatacaktır ve bir süre sonra dağıtımınız hazır olmalıdır. Dağıtım işleminiz çok zaman alıyorsa, dağıtımda bir hata oluşup oluşmadığını görmek için günlükleri kontrol edebilir veya Back4app’ın sorun giderme kılavuzuna bakabilirsiniz.

Sonuç

Bu makalede Deno’yu, avantajlarını, sınırlamalarını, popüler dağıtım seçeneklerini, Deno ile bir uygulamanın nasıl oluşturulacağını ve Back4app konteynerlerini kullanarak uygulamanızı nasıl dağıtacağınızı keşfettiniz.

Sınırlamalarına rağmen, güvenlik modeli nedeniyle Deno, çok güvenli ve hassas uygulamalar oluşturmak için ideal olabilir. Ek olarak, yerel TypeScript desteği, projenizde TypeScript kurma sorunlarını ortadan kaldırır.

Bu makalede özetlenen adımları izleyerek Deno uygulamanızı Back4app konteynerleri üzerinde kolayca oluşturabilir ve dağıtabilirsiniz.

SSS