டோக்கர் அமைப்பில் காஃப்காவுடனான ஸ்பார்க் தொழிலாளி இணைப்புச் சிக்கல்களைத் தீர்ப்பது

ஒரு ஆவணப்படுத்தப்பட்ட சூழலில் ஸ்பார்க் மற்றும் காஃப்காவை ஒருங்கிணைப்பதில் உள்ள சவால்கள்

ஒருங்கிணைக்கும் போது நீங்கள் எப்போதாவது இணைப்பு சிக்கலை எதிர்கொண்டிருக்கிறீர்களா? காஃப்கா தரகர் ஒரு ஸ்பார்க் கிளஸ்டர் டோக்கர் அமைப்பிற்குள்? நீங்கள் தனியாக இல்லை! இந்த இரண்டு சக்திவாய்ந்த கருவிகளுக்கு இடையே தகவல்தொடர்புகளை அமைக்கும் போது பல டெவலப்பர்கள் தடைகளை எதிர்கொள்கின்றனர். 🛠️

சமீபத்தில், நான் என்னை மேம்படுத்துவதில் இறங்கினேன் ஸ்பார்க் கிளஸ்டர் நிகழ்நேர தரவு செயலாக்கத்தை சீரமைக்க காஃப்கா தரகரைச் சேர்ப்பதன் மூலம். இருப்பினும், தொடர்ச்சியான இணைப்பு நேரமுடிவுகள் மற்றும் DNS தெளிவுத்திறன் பிழைகள் ஆகியவற்றுடன் நான் ஒரு சாலைத் தடுப்பைத் தாக்கினேன், இது செயல்முறையை சரிசெய்தல் மராத்தானாக மாற்றியது. 😅

இந்தச் சிக்கல்கள் டோக்கர் கம்போஸ் மற்றும் ஸ்பார்க்கின் காஃப்கா தொடர்பான உள்ளமைவுகளில் தவறாக உள்ளமைக்கப்பட்ட அமைப்புகளிலிருந்து உருவாகின்றன. பல வழிகாட்டிகளைப் பின்பற்றி, பல அளவுருக்களை மாற்றியமைத்த போதிலும், மழுப்பலான "தரகர் கிடைக்காமல் போகலாம்" என்ற செய்தி தொடர்ந்தது, என்னை குழப்பமாகவும் விரக்தியாகவும் ஆக்கியது.

இந்தக் கட்டுரையில், டோக்கர் சூழலில் ஸ்பார்க் தொழிலாளர்கள் மற்றும் காஃப்கா தரகர்களுக்கு இடையே உள்ள இணைப்புச் சவால்களைத் தீர்ப்பதற்கான நடைமுறைப் படிகளை எனது அனுபவத்தைப் பகிர்ந்து கொள்கிறேன். வழியில், இந்த ஆபத்துக்களைத் தவிர்ப்பதற்கும் தடையற்ற ஒருங்கிணைப்பை உறுதி செய்வதற்கும் உதவிக்குறிப்புகள் மற்றும் தந்திரங்களைக் கற்றுக்கொள்வீர்கள். உள்ளே நுழைவோம்! 🚀

டோக்கரில் ஸ்பார்க் மற்றும் காஃப்கா ஒருங்கிணைப்பைப் புரிந்துகொள்வது

முதல் ஸ்கிரிப்ட் a இடையே ஒரு இணைப்பை நிறுவுவதில் கவனம் செலுத்துகிறது தீப்பொறி தொழிலாளி மற்றும் ஏ காஃப்கா தரகர். ஸ்பார்க்கின் கட்டமைக்கப்பட்ட ஸ்ட்ரீமிங் API ஐப் பயன்படுத்துவதன் மூலம், ஸ்கிரிப்ட் காஃப்கா தலைப்பிலிருந்து நிகழ்நேரத் தரவைப் படிக்கிறது. இது ஒரு ஸ்பார்க் அமர்வை துவக்கி, தேவையான காஃப்கா தொகுப்புடன் கட்டமைப்பதில் தொடங்குகிறது. காஃப்காவுடன் தடையின்றி தொடர்புகொள்வதற்கு ஸ்பார்க்கிற்கு தேவையான சார்புநிலையை இது வழங்குவதால் இது மிகவும் முக்கியமானது. இந்த சார்புநிலைக்கு ஒரு எடுத்துக்காட்டு `org.apache.spark:spark-sql-kafka` தொகுப்பு ஆகும், இது டோக்கர் சூழலில் ஸ்பார்க்கிற்கும் காஃப்காவிற்கும் இடையிலான இணக்கத்தன்மையை உறுதி செய்கிறது.

காஃப்கா செய்திகளைக் கையாள, ஸ்கிரிப்ட் `StructType` ஐப் பயன்படுத்தி ஒரு திட்டத்தை வரையறுக்கிறது. உள்வரும் செய்திகள் சரியாகப் பாகுபடுத்தப்பட்டு கட்டமைக்கப்பட்டிருப்பதை இந்தத் திட்டம் உறுதி செய்கிறது. நிஜ-உலகக் காட்சிகள் பெரும்பாலும் காஃப்காவிலிருந்து JSON தரவைக் கையாளும். உதாரணமாக, காஃப்காவிற்கு விலை புதுப்பிப்புகளைக் கொண்ட செய்திகள் அனுப்பப்படும் கிரிப்டோகரன்சி கண்காணிப்பு அமைப்பை கற்பனை செய்து பாருங்கள். இந்தச் செய்திகளைப் படிக்கக்கூடிய வடிவத்தில் பாகுபடுத்துவது, போக்குக் கணிப்புக்கான தரவைச் செயலாக்குவது மற்றும் பகுப்பாய்வு செய்வதை எளிதாக்குகிறது. 🪙

இணைப்புச் சிக்கல்களைத் தீர்ப்பதில் டோக்கர் கம்போஸ் உள்ளமைவு முக்கியப் பங்கு வகிக்கிறது. `KAFKA_ADVERTISED_LISTENERS` மற்றும் `KAFKA_LISTENERS` அமைப்புகள் டோக்கர் நெட்வொர்க்கிற்குள் உள் மற்றும் வெளிப்புறத் தொடர்பை வேறுபடுத்தும் வகையில் சரிசெய்யப்படுகின்றன. ஸ்பார்க் மற்றும் காஃப்கா போன்ற ஒரே டோக்கர் நெட்வொர்க்கில் இயங்கும் சேவைகள் டிஎன்எஸ் தெளிவுத்திறன் சிக்கல்கள் இல்லாமல் செயல்படுவதை இது உறுதி செய்கிறது. எடுத்துக்காட்டாக, மேப்பிங் `INSIDE://kafka:9093` உள் கொள்கலன்கள் காஃப்காவை அணுக அனுமதிக்கிறது, அதே நேரத்தில் `OUTSIDE://localhost:9093` ஆனது கண்காணிப்பு கருவிகள் போன்ற வெளிப்புற பயன்பாடுகளை இணைக்க உதவுகிறது.

இரண்டாவது ஸ்கிரிப்ட் காஃப்கா இணைப்பைச் சோதிப்பதற்காக பைதான் `காஃப்கா நுகர்வோர்` எவ்வாறு பயன்படுத்துவது என்பதை விளக்குகிறது. காஃப்கா தரகர் சரியாகச் செயல்படுகிறாரா என்பதை உறுதிப்படுத்த இது ஒரு எளிய ஆனால் பயனுள்ள அணுகுமுறையாகும். குறிப்பிட்ட தலைப்பில் இருந்து செய்திகளைப் பயன்படுத்துவதன் மூலம், தரவு ஓட்டம் தடையின்றி உள்ளதா என்பதை நீங்கள் சரிபார்க்கலாம். ஒரு பயனர் பங்குச் சந்தைத் தரவைக் கண்காணிக்க விரும்பும் பயன்பாட்டைக் கவனியுங்கள். இந்த நுகர்வோர் ஸ்கிரிப்டைப் பயன்படுத்தி இணைப்பைச் சோதிப்பது, உள்ளமைவுப் பிழைகள் காரணமாக முக்கியமான புதுப்பிப்புகள் எதுவும் தவறவிடப்படுவதை உறுதி செய்கிறது. இந்த கருவிகள் மூலம், நிகழ்நேர தரவு செயலாக்கத்திற்கான வலுவான அமைப்புகளை நீங்கள் நம்பிக்கையுடன் பயன்படுத்தலாம்! 🚀

# Import necessary modules
from pyspark.sql import SparkSession
from pyspark.sql.types import StructType, StringType
from pyspark.sql.functions import from_json, col
# Initialize Spark session with Kafka dependency
spark = SparkSession.builder \
    .appName("KafkaDebugReader") \
    .config("spark.jars.packages", "org.apache.spark:spark-sql-kafka-0-10_2.12:3.5.0") \
    .getOrCreate()
# Define schema for Kafka message
schema = StructType().add("message", StringType())
# Set up Kafka source for streaming data
df = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "localhost:9093") \
    .option("subscribe", "crypto_topic") \
    .option("startingOffsets", "earliest") \
    .load()
# Parse Kafka message
messages = df.select(from_json(col("value").cast("string"), schema).alias("data")) \
    .select("data.message")
# Output data to console
query = messages.writeStream \
    .outputMode("append") \
    .format("console") \
    .start()
query.awaitTermination()

version: '3.8'
services:
  kafka:
    image: wurstmeister/kafka
    container_name: kafka
    ports:
      - "9093:9093"
    environment:
      KAFKA_ADVERTISED_LISTENERS: INSIDE://kafka:9093,OUTSIDE://localhost:9093
      KAFKA_LISTENERS: INSIDE://:9093,OUTSIDE://0.0.0.0:9093
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INSIDE:PLAINTEXT,OUTSIDE:PLAINTEXT
    networks:
      - my_network
  zookeeper:
    image: zookeeper
    container_name: zookeeper
    ports:
      - "2181:2181"
    networks:
      - my_network
networks:
  my_network:
    driver: bridge

# Import KafkaConsumer from Kafka library
from kafka import KafkaConsumer
# Create a Kafka Consumer instance
consumer = KafkaConsumer(
    'crypto_topic',
    bootstrap_servers='kafka:9093',
    auto_offset_reset='earliest',
    enable_auto_commit=False,
    group_id='api_data'
)
# Poll messages from Kafka topic
for message in consumer:
    print(f"Received message: {message.value.decode('utf-8')}")
# Ensure to close the consumer
consumer.close()

டாக்கரைஸ்டு சூழலில் காஃப்கா மற்றும் ஸ்பார்க்கை மேம்படுத்துதல்

இடையே சுமூகமான தொடர்பை உறுதி செய்வதற்கான முக்கியமான அம்சம் காஃப்கா தரகர்கள் மற்றும் தீப்பொறி தொழிலாளர்கள் டோக்கரில் நெட்வொர்க் அமைப்புகளை திறம்பட உள்ளமைக்கிறது. டோக்கர் கன்டெய்னர்கள் தனிமைப்படுத்தப்பட்ட சூழலில் இயங்குகின்றன, சேவைகள் தொடர்பு கொள்ள வேண்டியிருக்கும் போது பெரும்பாலும் DNS ரெசல்யூஷன் சிக்கல்களை ஏற்படுத்தும். இதை நிவர்த்தி செய்ய, நீங்கள் டோக்கர் கம்போஸின் நெட்வொர்க் உள்ளமைவு விருப்பங்களைப் பயன்படுத்தலாம். உதாரணமாக, `my_network` போன்ற தனிப்பயன் நெட்வொர்க்கை வரையறுப்பது மற்றும் சேவைகளை இணைப்பது, கொள்கலன்கள் ஐபியை விட பெயரால் ஒன்றையொன்று அடையாளம் கண்டுகொள்வதை உறுதிசெய்கிறது, இது அமைப்பை எளிதாக்குகிறது மற்றும் பொதுவான சிக்கல்களைத் தவிர்க்கிறது.

காஃப்காவின் கேட்போர் உள்ளமைவுகளை மேம்படுத்துவது மற்றொரு முக்கியமான கருத்தாகும். உங்கள் டோக்கர் கம்போஸ் கோப்பில் `KAFKA_ADVERTISED_LISTENERS' மற்றும் `KAFKA_LISTENERS' ஆகியவற்றைக் குறிப்பிடுவதன் மூலம், அதன் வாடிக்கையாளர்களுக்கு பொருத்தமான முகவரிகளை விளம்பரப்படுத்த காஃப்காவை அனுமதிக்கிறீர்கள். உள் மற்றும் வெளிப்புற கேட்பவர்களுக்கிடையேயான இந்த வேறுபாடு முரண்பாடுகளைத் தீர்க்கிறது, குறிப்பாக ஸ்பார்க் தொழிலாளர்கள் டோக்கர் நெட்வொர்க்கிற்கு வெளியே இருந்து இணைக்க முயற்சிக்கும் போது. இதற்கு நிஜ வாழ்க்கை உதாரணம், ஒரு ஹோஸ்ட் மெஷினிலிருந்து காஃப்கா தரவைக் கேட்கும் கண்காணிப்பு டாஷ்போர்டு, அணுகலுக்கு ஒரு தனித்துவமான வெளிப்புற கேட்பவர் தேவை. 🔧

இறுதியாக, உங்கள் ஸ்பார்க் பயன்பாடுகளில் வலுவான பிழை கையாளுதலை செயல்படுத்துவது மிகவும் முக்கியமானது. எடுத்துக்காட்டாக, காஃப்கா உள்ளமைவுக்குள்ளேயே மீண்டும் முயற்சிகள் மற்றும் பின்னடைவுகளை மேம்படுத்துவது தற்காலிக இணைப்புச் சிக்கல்களை அழகாகக் கையாளும். `.option("kafka.consumer.max.poll.records", "500")` ஐச் சேர்ப்பது அதிக சுமைகளின் கீழும் திறமையான தரவு மீட்டெடுப்பை உறுதி செய்கிறது. நிகழ்நேரத்தில் பங்கு விலைகளைக் கண்காணிக்கும் ஒரு தயாரிப்பு-தர பயன்பாட்டை கற்பனை செய்து பாருங்கள் - தோல்வி-பாதுகாப்புகளை வைத்திருப்பது பிணைய விக்கல்களின் போதும் தடையற்ற தரவு ஓட்டத்தை உறுதி செய்கிறது. இந்த நுட்பங்கள் ஒன்றாக நம்பகமான தரவு செயலாக்க குழாயின் முதுகெலும்பாக அமைகின்றன. 🚀