Python ile İlk Slack Botunuzu İnşa Etmek: Adım Adım Kapsamlı Bir Rehber

Python ile İlk Slack Botunuzu İnşa Etmek: Adım Adım Kapsamlı Bir Rehber

Slack, modern ekiplerin iletişim kurma ve işbirliği yapma biçimini değiştiren güçlü bir platformdur. Ancak Slack’in gerçek potansiyeli, çeşitli otomasyon ve entegrasyon yetenekleriyle ortaya çıkar. Bu yeteneklerin başında Slack botları gelir. Bir Slack botu, belirli olaylara tepki veren, mesajlar gönderen, kullanıcılarla etkileşim kuran ve hatta harici hizmetlerle bağlantı kurarak iş akışlarını otomatikleştiren bir uygulamadır. Bu makalede, Python programlama dilini kullanarak sıfırdan ilk Slack botunuzu nasıl inşa edeceğinizi adım adım öğreneceksiniz.

Bu rehber, Slack botlarının temel kavramlarından başlayarak, bir Slack uygulaması oluşturma, gerekli izinleri ayarlama, Python ortamınızı yapılandırma, ilk bot kodunuzu yazma, daha gelişmiş özellikler ekleme ve botunuzu çalıştırma konularını kapsayacaktır. İster günlük işlerinizi kolaylaştırmak, ister eğlenceli bir araç yaratmak isteyin, Python ile kendi Slack botunuzu geliştirmek, hem faydalı hem de öğretici bir deneyim olacaktır. Hazırsanız, bu heyecan verici yolculuğa başlayalım!

Ön Gereksinimler

Bu rehbere başlamadan önce, aşağıdaki temel gereksinimlere sahip olduğunuzdan emin olun:

* Python 3.7 veya üzeri: Python’ın kurulu olduğundan ve pip paket yöneticisinin çalıştığından emin olun. Komut istemcinizde python --version ve pip --version komutlarını çalıştırarak kontrol edebilirsiniz.
* Slack Çalışma Alanı: Bir Slack çalışma alanına erişiminiz olmalı ve bu alanda uygulama oluşturma ve yükleme yetkisine sahip olmalısınız. Kendi test çalışma alanınızı oluşturmak en iyisidir.
* Temel Python Bilgisi: Fonksiyonlar, değişkenler, listeler ve sözlükler gibi temel Python kavramlarına aşina olmanız beklenmektedir.
* Komut Satırı Temelleri: Terminal veya komut istemcisini kullanma konusunda temel bilgiye sahip olmanız faydalı olacaktır.

Slack Uygulaması Oluşturma ve Yetkilendirme

Slack botunuzu geliştirmeye başlamadan önce, Slack’in API platformunda botunuz için bir uygulama oluşturmanız ve gerekli izinleri (scopes) yapılandırmanız gerekir. Bu işlem, botunuzun Slack çalışma alanınızda belirli eylemleri gerçekleştirmesine olanak tanır.

Yeni Bir Slack Uygulaması Oluşturma

İlk adım, Slack API web sitesine giderek yeni bir uygulama oluşturmaktır:

1. Tarayıcınızda [api.slack.com/apps](https://api.slack.com/apps) adresine gidin.
2. “Create New App” (Yeni Uygulama Oluştur) düğmesine tıklayın.
3. “From scratch” (Sıfırdan) seçeneğini seçin.
4. Uygulamanıza bir isim verin (örneğin, “MyFirstPythonBot”). Bu isim, Slack çalışma alanınızda botunuzun görünen adı olacaktır.
5. Botu yüklemek istediğiniz Slack çalışma alanını seçin ve “Create App” (Uygulama Oluştur) düğmesine tıklayın.

Uygulamanız başarıyla oluşturulduktan sonra, sizi uygulamanızın temel bilgilerinin bulunduğu sayfaya yönlendirecektir.

Bot Token Yetkilendirmeleri (Scopes) Ekleme

Botunuzun Slack’te belirli eylemleri gerçekleştirebilmesi için ona yetki vermeniz gerekir. Bu yetkilere “scopes” (kapsamlar) denir. Sol menüden “OAuth & Permissions” (OAuth ve İzinler) bölümüne gidin ve “Bot Token Scopes” (Bot Token Kapsamları) başlığı altında aşağıdaki kapsamları ekleyin:

* app_mentions:read: Botun kendisinden bahsedilen mesajları okumasını sağlar.
* chat:write: Botun kanallara veya kullanıcılara mesaj göndermesini sağlar.
* channels:read: Botun katıldığı genel kanalların listesini ve detaylarını okumasını sağlar.
* groups:read: Botun katıldığı özel kanalların (private channels/groups) listesini ve detaylarını okumasını sağlar.
* im:read: Botun direkt mesaj (DM) kanallarını okumasını sağlar.
* mpim:read: Botun çoklu kişi direkt mesaj (MPDM) kanallarını okumasını sağlar.

Bu kapsamlar, botunuzun temel etkileşimler için yeterli yetkiye sahip olmasını sağlar. İhtiyaçlarınıza göre daha fazla kapsam eklemeniz gerekebilir. Kapsamları ekledikten sonra, sayfanın üst kısmında bir uyarı göreceksiniz: “Install your app to your workspace” (Uygulamanızı çalışma alanınıza yükleyin).

Uygulamayı Çalışma Alanına Yükleme ve Bot Token’ı Alma

Kapsamları ekledikten sonra, uygulamanızı Slack çalışma alanınıza yüklemeniz gerekir. Bu işlem, botunuz için bir “Bot User OAuth Token” oluşturacaktır.

1. “Install to Workspace” (Çalışma Alanına Yükle) düğmesine tıklayın.
2. Slack, uygulamanızın isteyeceği izinleri özetleyen bir onay ekranı gösterecektir. “Allow” (İzin Ver) düğmesine tıklayarak onaylayın.
3. Başarılı bir yüklemeden sonra, “OAuth & Permissions” sayfasına geri döneceksiniz. Bu sayfada, “Bot User OAuth Token” altında xoxb- ile başlayan bir token göreceksiniz.

Bu token, botunuzun Slack API ile kimlik doğrulaması yapmak için kullanacağı anahtardır. Bu token’ı kesinlikle kimseyle paylaşmayın ve güvenli bir yerde saklayın. Geliştirme ortamınızda bu token’ı bir ortam değişkeni olarak saklayacağız. Şimdilik kopyalayıp bir yere yapıştırın.

Geliştirme Ortamını Hazırlama

Python ile bot geliştirirken en iyi uygulama, her proje için izole bir sanal ortam kullanmaktır. Bu, proje bağımlılıklarının sistem genelindeki Python kurulumunuzu etkilemesini önler.

Sanal Ortam Oluşturma

Projeniz için bir dizin oluşturun ve bu dizin içinde bir sanal ortam başlatın:

mkdir my-slack-bot
cd my-slack-bot
python -m venv venv

Sanal ortamı etkinleştirin:

* Windows:

.\venv\Scripts\activate

* macOS/Linux:

source venv/bin/activate

Komut istemcinizin başında (venv) gördüğünüzde, sanal ortamınızın etkin olduğu anlamına gelir.

Gerekli Kütüphaneleri Yükleme

Slack botunuzu geliştirmek için Slack’in resmi Python SDK’sını ve ortam değişkenlerini yönetmek için python-dotenv kütüphanesini yükleyeceğiz:

pip install slack_sdk python-dotenv

* slack_sdk: Slack API ile etkileşim kurmayı sağlayan resmi Python kütüphanesi.
* python-dotenv: Ortam değişkenlerini .env dosyasından yüklemek için kullanılır, böylece hassas bilgiler (API token’ları gibi) kodunuzda görünmez.

Ortam Değişkenlerini Ayarlama (.env Dosyası)

Token’ınızı doğrudan kodunuza yazmak yerine, .env adlı bir dosyada saklayacağız. Bu, hassas bilgilerinizi güvende tutmanın ve kodunuzu daha taşınabilir hale getirmenin en iyi yoludur.

Proje dizininizin kökünde my-slack-bot içinde .env adında yeni bir dosya oluşturun ve içine aşağıdaki satırı ekleyin, xoxb-YOUR-BOT-TOKEN kısmını kendi bot token’ınızla değiştirin:

SLACK_BOT_TOKEN=xoxb-YOUR-BOT-TOKEN

Ayrıca, botunuzun Slack sunucusuyla bağlantı kurmak için “Socket Mode” kullanacağız. Bunun için bir “App-Level Token” da gerekecek. Slack uygulamanızın ayarlarında (api.slack.com/apps adresindeki uygulamanızın sayfasında) sol menüden “Basic Information” -> “App-Level Tokens” bölümüne gidin. “Generate Token” düğmesine tıklayın, token’a bir isim verin (örneğin, socket_mode_token) ve connections:write kapsamını seçin. Oluşturulan xapp- ile başlayan token’ı kopyalayın ve .env dosyanıza ekleyin:

SLACK_BOT_TOKEN=xoxb-YOUR-BOT-TOKEN
SLACK_APP_TOKEN=xapp-YOUR-APP-LEVEL-TOKEN

Önemli: .env dosyasını sürüm kontrol sisteminize (örneğin Git) eklemeyin. .gitignore dosyanıza /.env satırını ekleyerek bu dosyayı görmezden gelmesini sağlayın.

İlk Bot Kodunuzu Yazma (Socket Mode ile)

Artık Slack uygulamanız hazır, ortamınız yapılandırıldı ve token’larınız güvende. İlk Python Slack bot kodumuzu yazmaya başlayabiliriz. Modern Slack botları için SocketModeClient kullanarak botunuzun Slack sunucusuyla sürekli bir bağlantı kurmasını ve olayları gerçek zamanlı olarak dinlemesini sağlayacağız. Bu yöntem, botunuzu herkese açık bir HTTP uç noktasına dağıtma ihtiyacını ortadan kaldırır, bu da geliştirme ve dağıtımı önemli ölçüde basitleştirir.

Proje dizininizin kökünde app.py adında yeni bir dosya oluşturun ve aşağıdaki kodu ekleyin:

import os
import logging
from slack_sdk import WebClient
from slack_sdk.socket_mode import SocketModeClient
from dotenv import load_dotenv

Ortam değişkenlerini .env dosyasından yükle
load_dotenv()

Logger yapılandırması
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

Ortam değişkenlerinden token'ları al
SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
SLACK_APP_TOKEN = os.environ.get("SLACK_APP_TOKEN")

Token'ların varlığını kontrol et
if not SLACK_BOT_TOKEN or not SLACK_APP_TOKEN:
    logger.error("SLACK_BOT_TOKEN veya SLACK_APP_TOKEN ortam değişkeni ayarlanmamış.")
    exit(1)

Slack WebClient'ı başlat (API çağrıları için)
Bu client, mesaj göndermek, kanal bilgilerini almak gibi işlemlerde kullanılır.
web_client = WebClient(token=SLACK_BOT_TOKEN)

Slack SocketModeClient'ı başlat (olayları dinlemek için)
Bu client, botunuzun Slack'ten gelen olayları (mesajlar, mention'lar vb.) almasını sağlar.
socket_mode_client = SocketModeClient(
    app_token=SLACK_APP_TOKEN,
    web_client=web_client  # WebClient'ı burada da kullanabiliriz
)

Botun kendisinden bahsedildiğinde (örneğin, "@MyFirstPythonBot merhaba") çalışacak fonksiyon
def process_app_mention(client: SocketModeClient, req):
    """
    Botun kendisinden bahsedildiğinde tetiklenen olay işleyici.
    Gelen isteği (req) işler ve bir yanıt gönderir.
    """
    # Gelen olayın türünü ve içeriğini kontrol et
    event = req.payload.get("event", {})
    event_type = event.get("type")
    
    # Sadece "app_mention" olaylarını işle
    if event_type == "app_mention":
        channel_id = event.get("channel")
        user_id = event.get("user")
        text = event.get("text")
        
        logger.info(f"Kanal: {channel_id}, Kullanıcı: {user_id}, Mesaj: {text}")

        # Basit bir "Merhaba!" yanıtı gönder
        try:
            web_client.chat_postMessage(
                channel=channel_id,
                text=f"Merhaba <@{user_id}>! Ben ilk Python botunuzum."
            )
            logger.info(f"Yanıt gönderildi: Merhaba {user_id}!")
        except Exception as e:
            logger.error(f"Mesaj gönderme hatası: {e}")

Botun olayları dinlemesini sağlayan handler'ı ekle
"app_mention" olaylarını dinlemek için "app_mention" event_type'ını belirtiyoruz.
socket_mode_client.events_api.on("app_mention", process_app_mention)

logger.info("Bot başlatılıyor...")

Botu başlat ve sonsuza dek çalıştır
Bu, botunuzun Slack ile bağlantısını sürekli açık tutar ve olayları dinlemesini sağlar.
socket_mode_client.connect()
socket_mode_client.start() # Bu çağrı botu ana thread'de çalıştırır ve bloklar

Kodu Açıklama

1. İçe Aktarmalar:
* os: Ortam değişkenlerine erişmek için.
* logging: Botun çalışma zamanı bilgilerini ve hatalarını kaydetmek için.
* slack_sdk.WebClient: Slack API’ye HTTP istekleri göndermek için kullanılır (örneğin, mesaj göndermek).
* slack_sdk.socket_mode.SocketModeClient: Slack’ten gelen olayları gerçek zamanlı olarak dinlemek için kullanılır.
* dotenv.load_dotenv: .env dosyasındaki ortam değişkenlerini yüklemek için.

2. Token Yükleme ve Kontrol:
* load_dotenv(): Proje dizinindeki .env dosyasını yükler.
* os.environ.get(...): SLACK_BOT_TOKEN ve SLACK_APP_TOKEN değerlerini ortam değişkenlerinden alır.
* Token’ların eksik olması durumunda hata mesajı verir ve programdan çıkar.

3. Client Başlatma:
* web_client = WebClient(token=SLACK_BOT_TOKEN): Slack API’ye istek göndermek için WebClient örneği oluşturulur. Botun mesaj göndermesi gibi eylemleri bu client üzerinden yapılır.
* socket_mode_client = SocketModeClient(...): Slack’ten gelen olayları dinlemek için SocketModeClient örneği oluşturulur. app_token ve web_client parametreleri zorunludur.

4. Olay İşleyici Fonksiyon (process_app_mention):
* Bu fonksiyon, botun kendisinden Slack’te bahsedildiğinde (@MyFirstPythonBot merhaba gibi) tetiklenir.
* req parametresi, Slack’ten gelen olayın tüm detaylarını içeren bir nesnedir.
* req.payload.get("event", {}) ile olayın içeriğine erişilir.
* channel_id ve user_id, olayın gerçekleştiği kanal ve olayı tetikleyen kullanıcının ID’sidir.
* web_client.chat_postMessage(...) kullanılarak channel_id‘ye bir mesaj gönderilir. Mesajda, user_id ile kullanıcıdan bahsedilir (<@{user_id}>).

5. Olayı Dinleme ve Botu Başlatma:
* socket_mode_client.events_api.on("app_mention", process_app_mention): SocketModeClient‘a, “app\_mention” türündeki bir olay geldiğinde process_app_mention fonksiyonunu çalıştırmasını söyler.
* socket_mode_client.connect(): Botu Slack sunucusuna bağlar.
* socket_mode_client.start(): Botu dinleme modunda başlatır ve programın çalışmaya devam etmesini sağlar.

Botu Çalıştırma ve Test Etme

Artık kodunuz hazır olduğuna göre, botunuzu çalıştırabilir ve Slack çalışma alanınızda test edebilirsiniz.

1. Botu Çalıştırma:
Sanal ortamınızın etkin olduğundan emin olun ve proje dizininizde aşağıdaki komutu çalıştırın:

python app.py

Terminalinizde “Bot başlatılıyor…” ve ardından “INFO” seviyesinde log mesajları görmelisiniz. Bu, botunuzun başarıyla başladığı ve Slack’ten olayları dinlediği anlamına gelir.

2. Slack’te Test Etme:
* Slack çalışma alanınızı açın.
* Botunuzu eklediğiniz bir kanala gidin (veya botunuzu bir kanala davet edin). Botunuzun kanal üyesi olması gerekir.
* Botunuzdan bahsederek bir mesaj gönderin: @MyFirstPythonBot merhaba (Botunuzun adını doğru yazdığınızdan emin olun).
* Botunuzun size “Merhaba <@kullanıcı_adı>! Ben ilk Python botunuzum.” şeklinde yanıt vermesi gerekir.

Eğer botunuz yanıt vermezse, terminaldeki log mesajlarını kontrol edin. Hata mesajları, sorunun kaynağını anlamanıza yardımcı olabilir.

Botu Geliştirme: Daha Fazla Özellik

İlk basit botunuzu çalıştırdığınıza göre, onu daha akıllı ve kullanışlı hale getirmek için bazı ek özellikler ekleyelim.

Farklı Olayları Dinleme (Örneğin, message Olayı)

Botunuz sadece kendisinden bahsedildiğinde değil, belirli kanallardaki tüm mesajları da dinleyebilir. Bu, daha genel amaçlı botlar için kullanışlıdır. message olayını dinlemek için process_app_mention fonksiyonuna benzer yeni bir işleyici oluşturabiliriz.

app.py dosyanıza process_message adında yeni bir fonksiyon ekleyin:

# ... (önceki kod) ...

def process_message(client: SocketModeClient, req):
    """
    Kanalda gönderilen her mesaj için tetiklenen olay işleyici.
    """
    event = req.payload.get("event", {})
    event_type = event.get("type")
    
    # Sadece "message" olaylarını ve botun kendi mesajlarını göz ardı et
    if event_type == "message" and "subtype" not in event and event.get("bot_id") is None:
        channel_id = event.get("channel")
        user_id = event.get("user")
        text = event.get("text")
        
        logger.info(f"Mesaj (Kanal: {channel_id}, Kullanıcı: {user_id}): {text}")

        # Eğer mesaj "saat kaç" içeriyorsa, saate yanıt ver
        if "saat kaç" in text.lower():
            import datetime
            now = datetime.datetime.now().strftime("%H:%M:%S")
            try:
                web_client.chat_postMessage(
                    channel=channel_id,
                    text=f"Şu anki saat: {now}"
                )
                logger.info(f"Saate yanıt gönderildi: {now}")
            except Exception as e:
                logger.error(f"Saate yanıt gönderme hatası: {e}")

... (önceki kod) ...

"message" olaylarını dinlemek için handler'ı ekle
socket_mode_client.events_api.on("message", process_message)

logger.info("Bot başlatılıyor...")
... (kalan kod) ...

Bu kod parçası, eğer bir mesaj “saat kaç” ifadesini içeriyorsa, botun o anki saati yanıt olarak göndermesini sağlar. subtype not in event kontrolü, mesajın bir dosya yüklemesi veya kanal katılımı gibi özel bir tür olmadığını garanti ederken, event.get("bot_id") is None kontrolü botun kendi mesajlarını işlemesini engeller, böylece sonsuz döngülerin önüne geçilir.

Kullanıcı Girdisini İşleme (Regex Kullanarak)

Botunuzun daha karmaşık komutları anlaması için düzenli ifadeler (regex) kullanabilirsiniz. Örneğin, bir hava durumu botu için “hava durumu Ankara” gibi bir komutu ayrıştırmak isteyebilirsiniz.

process_message fonksiyonunu aşağıdaki gibi güncelleyelim, böylece “hava durumu [şehir]” komutunu işleyebilir:

import re # Düzenli ifadeler için
... (önceki kod) ...

def process_message(client: SocketModeClient, req):
    event = req.payload.get("event", {})
    event_type = event.get("type")
    
    if event_type == "message" and "subtype" not in event and event.get("bot_id") is None:
        channel_id = event.get("channel")
        user_id = event.get("user")
        text = event.get("text")
        
        logger.info(f"Mesaj (Kanal: {channel_id}, Kullanıcı: {user_id}): {text}")

        # Eğer mesaj "saat kaç" içeriyorsa, saate yanıt ver
        if "saat kaç" in text.lower():
            import datetime
            now = datetime.datetime.now().strftime("%H:%M:%S")
            try:
                web_client.chat_postMessage(
                    channel=channel_id,
                    text=f"Şu anki saat: {now}"
                )
                logger.info(f"Saate yanıt gönderildi: {now}")
            except Exception as e:
                logger.error(f"Saate yanıt gönderme hatası: {e}")

        # Hava durumu komutunu işle
        weather_pattern = re.compile(r"hava durumu (\w+)", re.IGNORECASE)
        match = weather_pattern.search(text)

        if match:
            city = match.group(1)
            # Burada gerçek bir hava durumu API'si ile entegrasyon yapılabilir.
            # Şimdilik basit bir mock yanıt gönderelim.
            try:
                web_client.chat_postMessage(
                    channel=channel_id,
                    text=f"{city} için hava durumu bilgisini getiriyorum... (Bu özellik henüz tam değil)"
                )
                logger.info(f"Hava durumu isteği alındı: {city}")
            except Exception as e:
                logger.error(f"Hava durumu yanıtı gönderme hatası: {e}")

Bu örnekte, re.compile() ile bir düzenli ifade deseni oluşturulur ve weather_pattern.search(text) ile gelen mesajda bu desen aranır. Eğer bir eşleşme bulunursa, match.group(1) ile şehir adı yakalanır ve bot buna göre yanıt verir.

Block Kit ile Daha Zengin Mesajlar Gönderme

Slack’in Block Kit’i, botunuzun daha görsel ve etkileşimli mesajlar göndermesini sağlar. Düğmeler, resimler, seçim menüleri gibi UI bileşenlerini kullanarak kullanıcı deneyimini zenginleştirebilirsiniz.

Aşağıdaki örnekte, bir düğme içeren bir mesaj nasıl gönderilir gösterilmiştir. Bu, process_app_mention veya process_message fonksiyonlarınızda kullanılabilir.

# ... (önceki kod) ...

def process_app_mention(client: SocketModeClient, req):
    event = req.payload.get("event", {})
    event_type = event.get("type")
    
    if event_type == "app_mention":
        channel_id = event.get("channel")
        user_id = event.get("user")
        text = event.get("text")
        
        logger.info(f"Kanal: {channel_id}, Kullanıcı: {user_id}, Mesaj: {text}")

        # Basit bir "Merhaba!" yanıtı gönder
        try:
            # Block Kit kullanarak daha zengin bir mesaj oluştur
            blocks = [
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": f"Merhaba <@{user_id}>! Ben ilk Python botunuzum. Size nasıl yardımcı olabilirim?"
                    }
                },
                {
                    "type": "actions",
                    "elements": [
                        {
                            "type": "button",
                            "text": {
                                "type": "plain_text",
                                "text": "Daha Fazla Bilgi"
                            },
                            "style": "primary",
                            "value": "more_info_clicked"
                        },
                        {
                            "type": "button",
                            "text": {
                                "type": "plain_text",
                                "text": "Yardım"
                            },
                            "value": "help_clicked"
                        }
                    ]
                }
            ]

            web_client.chat_postMessage(
                channel=channel_id,
                blocks=blocks # 'text' yerine 'blocks' parametresini kullanıyoruz
            )
            logger.info(f"Block Kit mesajı gönderildi: Merhaba {user_id}!")
        except Exception as e:
            logger.error(f"Block Kit mesajı gönderme hatası: {e}")

... (kalan kod) ...

Bu kod, kullanıcıdan bahsedildiğinde bir metin bölümü ve iki düğme içeren bir mesaj gönderir. Düğmelere tıklandığında, Slack botunuza bir “interaction” (etkileşim) olayı gönderir. Bu olayları dinlemek ve işlemek için Slack uygulamanızda “Interactivity & Shortcuts” bölümünü yapılandırmanız ve bir “Request URL” sağlamanız gerekir. Ancak Socket Mode kullanırken, bu etkileşim olaylarını doğrudan botunuzda dinleyebilirsiniz:

# ... (önceki kod) ...

from slack_sdk.socket_mode.request import SocketModeRequest

Etkileşim olaylarını işlemek için yeni bir fonksiyon
def process_interaction(client: SocketModeClient, req: SocketModeRequest):
    if req.type == "interactive":
        payload = req.payload
        action_id = payload["actions"][0]["action_id"] # Veya value'yu kullanabilirsiniz
        user_id = payload["user"]["id"]
        channel_id = payload["channel"]["id"]
        
        logger.info(f"Etkileşim olayı alındı: Kullanıcı {user_id}, Aksiyon: {action_id}")

        if action_id == "more_info_clicked": # Eğer düğmelerin action_id'si varsa
            try:
                web_client.chat_postMessage(
                    channel=channel_id,
                    text=f"<@{user_id}>, daha fazla bilgi istediniz! İşte size bazı kaynaklar..."
                )
            except Exception as e:
                logger.error(f"Etkileşim yanıtı gönderme hatası: {e}")
        
        # Etkileşim isteğini onaylamak için
        client.send_response(req=req, payload={"status": "ok"})

... (kalan kod) ...

Etkileşim olaylarını dinlemek için handler'ı ekle
socket_mode_client.socket_mode_request_listeners.append(process_interaction)

logger.info("Bot başlatılıyor...")
... (kalan kod) ...

Bu örnekte, socket_mode_client.socket_mode_request_listeners.append(process_interaction) satırı ile process_interaction fonksiyonu, Socket Mode üzerinden gelen tüm interaktif istekleri dinlemek üzere kaydedilir. req.payload içindeki actions dizisinden düğme tıklama olayının action_id‘sine erişilebilir.

Botu Dağıtma

Botunuzu geliştirme ortamınızda çalıştırmak harika, ancak onu sürekli olarak kullanılabilir hale getirmek için bir sunucuya veya bulut platformuna dağıtmanız gerekir. SocketModeClient kullanmanın avantajı, herkese açık bir HTTP uç noktasına ihtiyacınız olmamasıdır, bu da dağıtımı basitleştirir.

#### Dağıtım Seçenekleri

1. Kendi Sunucunuzda: Botunuzu bir Linux sunucusunda veya sanal makinede çalıştırmak en doğrudan yoldur.
* Sunucunuza Python’ı ve gerekli kütüphaneleri kurun (pip install slack_sdk python-dotenv).
* .env dosyanızı sunucuya yükleyin (ancak sürüm kontrolüyle değil, güvenli bir şekilde).
* Botunuzu bir systemd servisi veya screen/tmux gibi bir araçla arka planda çalıştırın, böylece terminal oturumunuz kapansa bile çalışmaya devam eder.

2. Bulut Platformları (Heroku, Render, AWS EC2/ECS, Google Cloud Run): Bu platformlar, uygulamanızı yönetmeyi ve ölçeklendirmeyi kolaylaştırır. SocketModeClient ile çalışırken, temelde uygulamanızı normal bir Python betiği gibi çalıştırmanız yeterlidir.
* Heroku/Render: Bu platformlar genellikle Procfile adlı bir dosya gerektirir. Procfile dosyanızda botunuzu nasıl başlatacağınızı belirtirsiniz:

worker: python app.py

Ardından, .env dosyanızdaki ortam değişkenlerini platformun kendi yapılandırma değişkenleri (Heroku’da Config Vars, Render’da Environment Variables) olarak ayarlamanız gerekir.
* Docker: Uygulamanızı bir Docker konteynerine paketleyerek herhangi bir Docker uyumlu ortamda (AWS ECS, Google Cloud Run, Kubernetes) kolayca dağıtabilirsiniz.

#### Güvenlik Hususları

* Token’ları Gizli Tutma: Bot token’larınız ve uygulama token’larınız, botunuzun Slack’teki kimlik kartlarıdır. Asla genel depolarda (GitHub gibi) paylaşmayın. .env dosyaları ve platformların ortam değişkeni mekanizmaları bunun için tasarlanmıştır.
* Yetki Minimumu: Botunuza yalnızca ihtiyaç duyduğu kapsamları (scopes) verin. Gereksiz yetkiler vermek, güvenlik risklerini artırabilir.

Sıkça Sorulan Sorular ve Sorun Giderme

Bot geliştirme sürecinde karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

* Botum yanıt vermiyor, neden?
* Token’ları kontrol edin: .env dosyanızdaki SLACK_BOT_TOKEN ve SLACK_APP_TOKEN değerlerinin doğru olduğundan emin olun. Slack API sayfasından tekrar kontrol edin.
* Botunuzun çevrimiçi olduğundan emin olun: Terminalinizde python app.py komutunu çalıştırdığınızda herhangi bir hata mesajı olup olmadığını kontrol edin. Botunuzun başlatıldığına dair logları görmelisiniz.
* Botunuz kanalda mı? Botunuzu test ettiğiniz kanala davet ettiğinizden emin olun (/invite @MyFirstPythonBot).
* Kapsamları kontrol edin: Botunuzun mesajları okumak ve göndermek için gerekli app_mentions:read ve chat:write gibi yetkilere sahip olduğundan emin olun. Slack uygulamanızın “OAuth & Permissions” sayfasını kontrol edin. Yetkileri değiştirdiyseniz, uygulamayı çalışma alanına yeniden yüklemeniz gerekebilir.
* Olay işleyici hatası: process_app_mention veya process_message gibi işleyici fonksiyonlarınızda bir hata olabilir. Terminaldeki hata loglarını dikkatlice inceleyin.
* Socket Mode bağlantısı: Botunuzun Slack Socket Mode sunucusuyla bağlantı kurabildiğinden emin olun. Ağ veya güvenlik duvarı sorunları bağlantıyı engelleyebilir.

* slack_sdk.errors.SlackApiError: The request to the Slack API failed. hatası alıyorum.
* Bu genellikle yanlış veya süresi dolmuş bir token’dan kaynaklanır. SLACK_BOT_TOKEN değerini kontrol edin.
* Botunuzun belirli bir eylemi gerçekleştirmek için yeterli yetkiye (scope) sahip olmayabilir. İlgili kapsamı eklediğinizden ve uygulamayı yeniden yüklediğinizden emin olun.

* Ortam değişkenleri yüklenmiyor.
* python-dotenv kütüphanesinin yüklü olduğundan emin olun (pip install python-dotenv).
* .env dosyasının app.py ile aynı dizinde olduğundan emin olun.
* Dosya adının .env olduğundan ve büyük/küçük harf hassasiyeti olmadığından emin olun (bazı sistemlerde).

* Botum kendi mesajlarına yanıt veriyor ve sonsuz döngüye giriyor.
* message olaylarını işlerken, botun kendi mesajlarını göz ardı ettiğinizden emin olun. Genellikle event.get("bot_id") is None veya event.get("subtype") != "bot_message" gibi kontrollerle yapılır.

Sonuç

Bu kapsamlı rehberde, Python ve slack_sdk kütüphanesini kullanarak ilk Slack botunuzu nasıl oluşturacağınızı adım adım öğrendiniz. Slack uygulamanızı yapılandırmaktan, gerekli yetkilendirmeleri sağlamaya, Python geliştirme ortamınızı kurmaya ve Socket Mode kullanarak etkileşimli bot kodunuzu yazmaya kadar tüm süreci ele aldık. Ayrıca, botunuzu daha akıllı hale getirmek için farklı olayları dinleme, kullanıcı girdilerini işleme ve Block Kit ile zengin mesajlar gönderme gibi gelişmiş özelliklere de değindik.

Artık temel bir Slack botu oluşturma ve geliştirme becerilerine sahipsiniz. Bu bilgi birikimiyle, Slack çalışma alanınızdaki günlük görevleri otomatikleştirebilir, ekibinizin iş akışlarını iyileştirebilir veya sadece eğlenceli ve interaktif araçlar yaratabilirsiniz. Bot geliştirme dünyası oldukça geniştir ve Slack API’si sayısız entegrasyon ve otomasyon olanağı sunar.

Gelecekteki adımlarınız arasında şunlar olabilir:

* Daha fazla Slack API özelliği keşfetme: Modals, Shortcuts, Slash Commands gibi özelliklerle botunuzu daha etkileşimli hale getirin.
* Harici API’larla entegrasyon: Hava durumu, döviz kurları, proje yönetimi araçları veya şirket içi sistemler gibi diğer hizmetlerle botunuzu bağlayın.
* Veritabanı entegrasyonu: Botunuzun kalıcı verileri saklaması ve alması için bir veritabanı (SQLite, PostgreSQL vb.) kullanın.
* Asenkron işlemler: Botunuzun aynı anda birden fazla isteği işlemesini sağlamak için asyncio gibi asenkron programlama tekniklerini araştırın.
* Test ve hata ayıklama: Botunuzun kararlı çalıştığından emin olmak için otomatik testler yazın ve daha gelişmiş hata ayıklama tekniklerini öğrenin.

Slack botları, dijital çalışma alanınızı kişiselleştirmenin ve üretkenliği artırmanın güçlü bir yoludur. Python’ın esnekliği ve slack_sdk‘nın sağladığı kolaylık sayesinde, kendi özel botlarınızı oluşturmak hiç bu kadar erişilebilir olmamıştı. İyi kodlamalar!