DigitalOcean API Verilerini Django ile Görüntüleme Rehberi
Giriş
Günümüzün bulut tabanlı altyapıları, geliştiricilere ve sistem yöneticilerine kaynaklarını programatik olarak yönetme yeteneği sunar. DigitalOcean, sunduğu basit ve güçlü API’si ile bu programatik yönetimi kolaylaştırır. Bir yandan da Django, Python tabanlı, “pil dahil” felsefesiyle hızlı ve güvenli web uygulamaları geliştirmek için popüler bir çerçevedir. DigitalOcean API’sinden alınan verileri bir Django uygulaması içinde görüntülemek, özel kontrol panelleri oluşturmak, otomasyon süreçlerini izlemek veya bulut kaynaklarının durumunu kolayca görselleştirmek için harika bir yoldur.
Bu kapsamlı teknik makalede, DigitalOcean API’sinden veri çekmek, bu verileri Django modellerine entegre etmek ve son olarak kullanıcı dostu bir arayüzle web sayfanızda görüntülemek için adım adım bir rehber sunacağız. Ayrıca, güvenlik, performans ve en iyi uygulamalar gibi konulara da değineceğiz.
Neden DigitalOcean API ve Django?
DigitalOcean API’si, Droplet’ler, domain’ler, depolama birimleri, güvenlik duvarları ve daha fazlası dahil olmak üzere DigitalOcean kaynaklarınızı programatik olarak yönetmenize olanak tanır. Bu, manuel işlemleri otomatikleştirmek, özel izleme çözümleri oluşturmak veya CI/CD süreçlerinizi entegre etmek için güçlü bir araçtır.
Django ise, hızlı geliştirme döngüleri, ORM (Object-Relational Mapper) desteği, güçlü şablon motoru, admin paneli ve kapsamlı güvenlik özellikleri ile karmaşık web uygulamaları geliştirmek için idealdir. DigitalOcean API’sinden gelen verileri Django ile birleştirmek, bu verileri kullanıcı arayüzünde sunarken Django’nun tüm avantajlarından yararlanmanızı sağlar. Örneğin:
- Özelleştirilmiş Paneller: Kendi ihtiyaçlarınıza göre DigitalOcean kaynaklarınızın durumunu gösteren paneller oluşturabilirsiniz.
- Otomasyon İzleme: Otomatikleştirilmiş işlemlerin sonuçlarını veya durumlarını bir web arayüzünden takip edebilirsiniz.
- Veri Görselleştirme: Çekilen veriler üzerinde grafikler ve tablolar oluşturarak daha anlamlı içgörüler elde edebilirsiniz.
- Entegrasyon: DigitalOcean verilerini diğer sistemlerinizle (örneğin, faturalandırma veya envanter sistemleri) entegre edebilirsiniz.
Ön Gereksinimler
Bu rehberi takip edebilmek için aşağıdaki ön gereksinimlere sahip olmanız gerekmektedir:
- Python 3.x: Sisteminizde Python yüklü olmalıdır.
- Django: Python sanal ortamınızda Django kurulu olmalıdır.
- DigitalOcean Hesabı: Aktif bir DigitalOcean hesabınız olmalıdır.
- DigitalOcean API Token: DigitalOcean hesabınızdan bir Personal Access Token (PAT) oluşturmuş olmanız gerekmektedir. Bu token’ı güvenli bir yerde saklayın, çünkü API isteklerinizde kimlik doğrulaması için kullanılacaktır.
- Temel Python ve Django Bilgisi: Django projesi oluşturma, uygulama tanımlama, view’lar ve şablonlar hakkında temel bilgiye sahip olmanız beklenir.
DigitalOcean API’ye Genel Bakış ve API Token Oluşturma
DigitalOcean API’si, RESTful bir mimariye sahiptir ve JSON formatında veri döndürür. API’ye yapılan tüm istekler, bir Personal Access Token (PAT) ile kimlik doğrulaması gerektirir.
API Token Oluşturma
- DigitalOcean hesabınıza giriş yapın.
- Sol menüden “API” sekmesine gidin.
- “Tokens/Keys” altında “Generate New Token” düğmesine tıklayın.
- Token’ınıza açıklayıcı bir isim verin (örn: “DjangoAppToken”).
- Token’ın izinlerini seçin. Verileri sadece görüntülemek için “Read” izinleri yeterli olacaktır. Eğer kaynakları yönetmek isterseniz “Write” izinlerini de vermeniz gerekebilir. Ancak güvenlik açısından her zaman en az yetki prensibini uygulayın.
- “Generate Token” düğmesine tıklayın.
- Oluşturulan token’ı kopyalayın. Bu token’ı sadece bir kez görebilirsiniz, bu yüzden hemen güvenli bir yere kaydedin.
Bu token, API isteklerinizin Authorization başlığında Bearer şeklinde gönderilecektir.
Django Projesi Kurulumu
Şimdi bir Django projesi oluşturalım ve DigitalOcean API verilerini görüntülemek için gerekli temel yapılandırmayı yapalım.
1. Sanal Ortam Oluşturma ve Django Kurulumu
mkdir digitalocean_dashboard
cd digitalocean_dashboard
python3 -m venv venv
source venv/bin/activate # Linux/macOS
venv\Scripts\activate # Windows
pip install django requests python-digitalocean django-environrequests kütüphanesi, HTTP istekleri yapmak için kullanılacak. python-digitalocean ise DigitalOcean API’si için resmi olmayan ancak popüler bir Python istemcisidir. Bu rehberde requests kütüphanesini doğrudan kullanarak API etkileşimini daha temel seviyede göstereceğiz, ancak python-digitalocean kütüphanesini kullanmak genellikle daha kolaydır. django-environ ise çevre değişkenlerini yönetmek için kullanılacak.
2. Django Projesi ve Uygulaması Oluşturma
django-admin startproject dodashboard .
python manage.py startapp doapiBu komutlar, dodeshboard adında bir proje ve doapi adında bir uygulama oluşturur.
3. Uygulamayı settings.py‘ye Ekleme
dodeshboard/settings.py dosyasını açın ve INSTALLED_APPS listesine doapi uygulamasını ekleyin:
# dodashboard/settings.py
INSTALLED_APPS = [
# ... diğer uygulamalar
'doapi',
]4. URL Yapılandırması
dodeshboard/urls.py dosyasını açın ve doapi uygulamasının URL’lerini ana URL yapılandırmasına dahil edin:
# dodashboard/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('doapi/', include('doapi.urls')), # doapi uygulamasının URL'lerini dahil et
]Şimdi doapi uygulaması için doapi/urls.py dosyasını oluşturun:
# doapi/urls.py
from django.urls import path
from . import views
urlpatterns = [
path('droplets/', views.droplet_list, name='droplet_list'),
path('domains/', views.domain_list, name='domain_list'),
path('projects/', views.project_list, name='project_list'),
path('', views.dashboard_home, name='dashboard_home'),
]API Token’ını Güvenli Bir Şekilde Saklama (django-environ ile)
API token’larını doğrudan settings.py dosyasına yazmak güvenlik açısından kötü bir uygulamadır. Bu token’lar hassas bilgiler içerir ve versiyon kontrol sistemlerine (Git gibi) yüklenmemelidir. django-environ kütüphanesi, çevre değişkenlerini veya .env dosyalarını kullanarak bu tür hassas bilgileri güvenli bir şekilde yönetmenizi sağlar.
Projenizin kök dizininde (manage.py ile aynı yerde) .env adında bir dosya oluşturun ve DigitalOcean API token’ınızı buraya ekleyin:
# .env
DIGITALOCEAN_API_TOKEN="sizin_digitalocean_api_token'ınız_buraya".gitignore dosyanıza .env‘yi eklemeyi unutmayın:
# .gitignore
*.pyc
__pycache__/
.env
db.sqlite3Şimdi dodeshboard/settings.py dosyasını güncelleyerek bu token’ı çekelim:
# dodashboard/settings.py
import os
import environ
environ kütüphanesini başlat
env = environ.Env(
# default değerler veya tip dönüşümleri tanımlayabilirsiniz
DEBUG=(bool, False)
)
.env dosyasını oku
environ.Env.read_env(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), '.env'))
Diğer ayarlar...
DigitalOcean API Token'ını çevre değişkeninden çek
DIGITALOCEAN_API_TOKEN = env('DIGITALOCEAN_API_TOKEN')
DEBUG ayarını .env'den çek
DEBUG = env('DEBUG')
SECRET_KEY gibi diğer hassas bilgileri de buradan çekebilirsiniz
SECRET_KEY = env('DJANGO_SECRET_KEY', default='bir_varsayılan_değer_verilebilir_ama_üretimde_asla_kullanmayın')Bu yapılandırma ile DIGITALOCEAN_API_TOKEN değişkeni, .env dosyasından güvenli bir şekilde alınacaktır.
API Verilerini Çekme (Django View’ları ile)
Şimdi doapi/views.py dosyasını oluşturarak DigitalOcean API’sinden veri çekecek fonksiyonları yazalım. requests kütüphanesini kullanarak API’ye HTTP GET istekleri göndereceğiz.
Temel API İstek Fonksiyonu
Öncelikle, API isteklerini yapacak genel bir yardımcı fonksiyon tanımlayalım:
# doapi/views.py
import requests
from django.conf import settings
from django.shortcuts import render
DIGITALOCEAN_API_BASE_URL = "https://api.digitalocean.com/v2"
def _make_digitalocean_api_request(endpoint):
"""
DigitalOcean API'sine GET isteği yapar ve JSON yanıtını döndürür.
"""
headers = {
"Authorization": f"Bearer {settings.DIGITALOCEAN_API_TOKEN}",
"Content-Type": "application/json",
}
url = f"{DIGITALOCEAN_API_BASE_URL}/{endpoint}"
try:
response = requests.get(url, headers=headers)
response.raise_for_status() # HTTP hataları için istisna fırlat
return response.json()
except requests.exceptions.RequestException as e:
print(f"DigitalOcean API isteği başarısız oldu: {e}")
return NoneDroplet Listesini Çekme ve Görüntüleme
Şimdi bu yardımcı fonksiyonu kullanarak Droplet’leri çekelim ve bir Django şablonunda görüntülemek üzere hazırlayalım.
# doapi/views.py (devamı)
def droplet_list(request):
"""
DigitalOcean Droplet'lerini çeker ve listeler.
"""
data = _make_digitalocean_api_request("droplets")
if data and 'droplets' in data:
droplets = data['droplets']
else:
droplets = [] # Hata durumunda boş liste
context = {
'droplets': droplets
}
return render(request, 'doapi/droplet_list.html', context)Domain Listesini Çekme ve Görüntüleme
Benzer şekilde, domain’leri de çekebiliriz:
# doapi/views.py (devamı)
def domain_list(request):
"""
DigitalOcean Domain'lerini çeker ve listeler.
"""
data = _make_digitalocean_api_request("domains")
if data and 'domains' in data:
domains = data['domains']
else:
domains = []
context = {
'domains': domains
}
return render(request, 'doapi/domain_list.html', context)Project Listesini Çekme ve Görüntüleme
Ve projeleri çekme:
# doapi/views.py (devamı)
def project_list(request):
"""
DigitalOcean Projelerini çeker ve listeler.
"""
data = _make_digitalocean_api_request("projects")
if data and 'projects' in data:
projects = data['projects']
else:
projects = []
context = {
'projects': projects
}
return render(request, 'doapi/project_list.html', context)Dashboard Ana Sayfası
Genel bir dashboard ana sayfası da oluşturabiliriz:
# doapi/views.py (devamı)
def dashboard_home(request):
"""
DigitalOcean kaynaklarının özetini gösteren ana dashboard sayfası.
"""
droplets_data = _make_digitalocean_api_request("droplets")
domains_data = _make_digitalocean_api_request("domains")
projects_data = _make_digitalocean_api_request("projects")
num_droplets = len(droplets_data.get('droplets', [])) if droplets_data else 0
num_domains = len(domains_data.get('domains', [])) if domains_data else 0
num_projects = len(projects_data.get('projects', [])) if projects_data else 0
context = {
'num_droplets': num_droplets,
'num_domains': num_domains,
'num_projects': num_projects,
}
return render(request, 'doapi/dashboard_home.html', context)Veriyi Django Şablonlarında Görüntüleme
Şimdi API’den çekilen verileri Django şablonları (HTML dosyaları) kullanarak kullanıcı arayüzünde gösterelim.
Şablon Klasörü Oluşturma
doapi uygulaması içinde bir templates klasörü ve onun içinde de doapi adında başka bir klasör oluşturun:
digitalocean_dashboard/
├── dodashboard/
├── doapi/
│ ├── migrations/
│ ├── templates/
│ │ └── doapi/
│ │ ├── base.html
│ │ ├── dashboard_home.html
│ │ ├── droplet_list.html
│ │ ├── domain_list.html
│ │ └── project_list.html
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── models.py
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── manage.py
├── .env
└── venv/dodeshboard/settings.py dosyasında TEMPLATES ayarının APP_DIRS: True olduğundan emin olun, bu Django’nun her uygulamanın templates klasörünü aramasını sağlar.
Temel Şablon (base.html)
Tüm sayfalarımız için ortak bir yapı sağlayacak bir base.html şablonu oluşturalım:
DigitalOcean Dashboard - {% block title %}Ana Sayfa{% endblock %}
{% block content %}
{% endblock %}
Dashboard Ana Sayfa Şablonu (dashboard_home.html)
{% extends 'doapi/base.html' %}
{% block title %}Ana Sayfa{% endblock %}
{% block page_title %}DigitalOcean Genel Bakış{% endblock %}
{% block content %}
{% endblock %}Droplet Listesi Şablonu (droplet_list.html)
{% extends 'doapi/base.html' %}
{% block title %}Dropletler{% endblock %}
{% block page_title %}Droplet Listesi{% endblock %}
{% block content %}
{% if droplets %}
ID
İsim
Bölge
Boyut
Durum
IP Adresi
{% for droplet in droplets %}
{{ droplet.id }}
{{ droplet.name }}
{{ droplet.region.name }} ({{ droplet.region.slug }})
{{ droplet.size.slug }} ({{ droplet.size.memory }}MB RAM)
{{ droplet.status }}
{% for network in droplet.networks.v4 %}
{% if network.type == 'public' %}
{{ network.ip_address }}
{% endif %}
{% endfor %}
{% endfor %}
{% else %}
Hiç Droplet bulunamadı veya API'den veri çekilemedi.
{% endif %}
{% endblock %}Domain Listesi Şablonu (domain_list.html)
{% extends 'doapi/base.html' %}
{% block title %}Domainler{% endblock %}
{% block page_title %}Domain Listesi{% endblock %}
{% block content %}
{% if domains %}
İsim
TTL
Zone File Üretildi
{% for domain in domains %}
{{ domain.name }}
{{ domain.ttl }}
{{ domain.zone_file_generated_at }}
{% endfor %}
{% else %}
Hiç Domain bulunamadı veya API'den veri çekilemedi.
{% endif %}
{% endblock %}Proje Listesi Şablonu (project_list.html)
{% extends 'doapi/base.html' %}
{% block title %}Projeler{% endblock %}
{% block page_title %}Proje Listesi{% endblock %}
{% block content %}
{% if projects %}
ID
İsim
Açıklama
Amacı
Oluşturulma Tarihi
{% for project in projects %}
{{ project.id }}
{{ project.name }}
{{ project.description }}
{{ project.purpose }}
{{ project.created_at }}
{% endfor %}
{% else %}
Hiç Proje bulunamadı veya API'den veri çekilemedi.
{% endif %}
{% endblock %}Uygulamayı Çalıştırma
Tüm bu adımları tamamladıktan sonra, Django geliştirme sunucusunu başlatabilir ve uygulamanızı test edebilirsiniz:
python manage.py runserverTarayıcınızda http://127.0.0.1:8000/doapi/ adresine gidin. DigitalOcean kaynaklarınızın özetini ve detaylı listelerini görmelisiniz.
Gelişmiş Konular ve En İyi Uygulamalar
1. Önbellekleme (Caching)
DigitalOcean API’sine her sayfa yüklemede istek göndermek, hem API rate limit’lerinizi tüketebilir hem de uygulamanızın performansını düşürebilir. Bu nedenle, API verilerini önbelleğe almak önemlidir. Django’nun yerleşik önbellekleme çerçevesini kullanabilirsiniz.
Örnek (Basit Önbellekleme):
dodeshboard/settings.py içinde önbellekleme yapılandırması:
# dodashboard/settings.py
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'unique-snowflake',
'TIMEOUT': 300, # 5 dakika (saniye cinsinden)
}
}doapi/views.py içinde önbellekleme kullanımı:
# doapi/views.py
from django.core.cache import cache
... (diğer importlar ve _make_digitalocean_api_request fonksiyonu)
def _get_cached_digitalocean_data(endpoint, cache_key, timeout=300):
"""
API verilerini önbellekten çekmeye çalışır, yoksa API'den çeker ve önbelleğe kaydeder.
"""
data = cache.get(cache_key)
if not data:
data = _make_digitalocean_api_request(endpoint)
if data:
cache.set(cache_key, data, timeout)
return data
def droplet_list(request):
data = _get_cached_digitalocean_data("droplets", "do_droplets_cache")
# ... (geri kalan kod aynı)Bu şekilde, Droplet verileri 5 dakika boyunca önbellekte kalacak ve bu süre zarfında API’ye tekrar istek gönderilmeyecektir.
2. Arka Plan Görevleri (Celery)
Eğer API istekleri uzun sürüyorsa veya düzenli aralıklarla veri çekmeniz gerekiyorsa, bu işlemleri arka plan görevlerine devretmek iyi bir fikirdir. Celery, bu tür görevleri yönetmek için popüler bir Python kütüphanesidir. Celery ile API verilerini periyodik olarak çekip bir veritabanına kaydedebilir, böylece web uygulamanız her zaman güncel verilere hızlıca erişebilir.
3. Hata Yönetimi ve Loglama
API istekleri her zaman başarılı olmayabilir. Ağ sorunları, API limitlerine takılma, geçersiz token gibi durumlar hatalara yol açabilir. Bu hataları düzgün bir şekilde yönetmek ve loglamak önemlidir.
# doapi/views.py (genel API istek fonksiyonunda geliştirme)
import logging
logger = logging.getLogger(__name__)
def _make_digitalocean_api_request(endpoint):
# ... (önceki kod)
try:
response = requests.get(url, headers=headers)
response.raise_for_status()
return response.json()
except requests.exceptions.HTTPError as http_err:
logger.error(f"HTTP hatası oluştu: {http_err} - Yanıt: {response.text}")
return None
except requests.exceptions.ConnectionError as conn_err:
logger.error(f"Bağlantı hatası oluştu: {conn_err}")
return None
except requests.exceptions.Timeout as timeout_err:
logger.error(f"İstek zaman aşımına uğradı: {timeout_err}")
return None
except requests.exceptions.RequestException as req_err:
logger.error(f"DigitalOcean API isteği bilinmeyen bir hatayla başarısız oldu: {req_err}")
return NoneDjango’nun loglama yapılandırmasını kullanarak bu logları dosyalara veya diğer loglama servislerine yönlendirebilirsiniz.
4. Güvenlik İyileştirmeleri
API token’larını .env dosyası ile yönetmek iyi bir başlangıçtır. Üretim ortamında, bu token’ları daha da güvenli bir şekilde saklamak için HashiCorp Vault gibi sır yönetim çözümlerini veya bulut sağlayıcınızın (AWS Secrets Manager, Azure Key Vault vb.) sır yönetim hizmetlerini düşünebilirsiniz.
5. Sayfalandırma (Pagination)
DigitalOcean API’si, büyük veri kümeleri için sayfalandırma (pagination) sunar. Eğer çok sayıda Droplet veya domain’iniz varsa, API yanıtı tek bir istekte tüm veriyi döndürmeyebilir. Link başlığını ve page, per_page parametrelerini kullanarak sayfalar arasında gezmeniz gerekebilir.
# _make_digitalocean_api_request fonksiyonunda sayfalandırma örneği (basit)
def _make_digitalocean_api_request(endpoint, params=None):
# ... (headers, url tanımlamaları)
all_data = []
page = 1
per_page = 20 # DigitalOcean varsayılanı 20
while True:
current_params = params.copy() if params else {}
current_params.update({'page': page, 'per_page': per_page})
response = requests.get(url, headers=headers, params=current_params)
response.raise_for_status()
json_data = response.json()
# API yanıtındaki anahtar ismine göre veriyi al
if endpoint == "droplets":
all_data.extend(json_data.get('droplets', []))
elif endpoint == "domains":
all_data.extend(json_data.get('domains', []))
elif endpoint == "projects":
all_data.extend(json_data.get('projects', []))
# ... diğer endpointler için ekle
# Sonraki sayfa olup olmadığını kontrol et
if 'pages' in json_data['links'] and 'next' in json_data['links']['pages']:
page += 1
else:
break
return {endpoint: all_data} # Tüm veriyi tek bir sözlükte döndürBu örnek, tüm sayfaları otomatik olarak çekmek için basit bir döngü kullanır. Gerçek bir uygulamada, bu mantığı daha esnek hale getirebilir veya kullanıcının sayfalar arasında gezinmesine izin verebilirsiniz.
6. Veri Modelleme ve Veritabanına Kayıt
Eğer API’den gelen veriler üzerinde karmaşık sorgular yapmanız, arama veya filtreleme uygulamanız gerekiyorsa, bu verileri Django modelleri aracılığıyla kendi veritabanınıza kaydetmek daha mantıklı olabilir. Bu durumda, API’den verileri çeken bir Celery görevi, bu verileri düzenli olarak veritabanınızdaki modellere senkronize ederdi.
Örnek Model (doapi/models.py):
# doapi/models.py
from django.db import models
class Droplet(models.Model):
droplet_id = models.IntegerField(unique=True)
name = models.CharField(max_length=255)
region_slug = models.CharField(max_length=50)
size_slug = models.CharField(max_length=50)
status = models.CharField(max_length=50)
ip_address = models.GenericIPAddressField(null=True, blank=True)
created_at = models.DateTimeField()
def __str__(self):
return self.nameAPI’den gelen verileri bu modele kaydetmek için bir senkronizasyon fonksiyonu yazılabilir:
# doapi/tasks.py (Celery kullanıyorsanız) veya doapi/utils.py
from .models import Droplet
from .views import _make_digitalocean_api_request # API isteği yapan fonksiyonu import et
def sync_droplets_from_do():
droplets_data = _make_digitalocean_api_request("droplets")
if droplets_data and 'droplets' in droplets_data:
for do_droplet in droplets_data['droplets']:
ip_address = None
for network in do_droplet['networks']['v4']:
if network['type'] == 'public':
ip_address = network['ip_address']
break
droplet, created = Droplet.objects.update_or_create(
droplet_id=do_droplet['id'],
defaults={
'name': do_droplet['name'],
'region_slug': do_droplet['region']['slug'],
'size_slug': do_droplet['size']['slug'],
'status': do_droplet['status'],
'ip_address': ip_address,
'created_at': do_droplet['created_at'],
}
)
if created:
print(f"Yeni Droplet eklendi: {droplet.name}")
else:
print(f"Droplet güncellendi: {droplet.name}")Bu yaklaşım, API’ye bağımlılığı azaltır ve uygulama performansını artırır, ancak verilerin güncelliğini korumak için düzenli senkronizasyon gerektirir.
Sonuç
Bu makalede, DigitalOcean API’sinden veri çekmek ve bu verileri Django web uygulamasında görüntülemek için kapsamlı bir rehber sunduk. DigitalOcean API token’ını güvenli bir şekilde yönetmekten, requests kütüphanesi ile API istekleri yapmaya, çekilen verileri Django şablonlarında göstermeye kadar birçok konuyu ele aldık. Ayrıca, önbellekleme, arka plan görevleri, hata yönetimi ve veritabanı entegrasyonu gibi gelişmiş konulara da değinerek uygulamanızın performansını ve güvenliğini artırmak için en iyi uygulamaları tartıştık.
Bu rehber, DigitalOcean kaynaklarınızın durumunu izlemek, özel bir kontrol paneli oluşturmak veya bulut altyapınızla etkileşim kuran daha karmaşık otomasyon çözümleri geliştirmek için sağlam bir temel oluşturmaktadır. Django’nun esnekliği ve DigitalOcean API’sinin gücü birleştiğinde, bulut kaynaklarınızı kendi ihtiyaçlarınıza göre şekillendirme konusunda sınırsız olanaklara sahip olursunuz. Unutmayın, API token’larınızın güvenliğini sağlamak her zaman en yüksek önceliğiniz olmalıdır.