$lang['tuto'] = "பயிற்சிகள்"; ?>$lang['tuto'] = "பயிற்சிகள்"; ?>$lang['tuto'] = "பயிற்சிகள்"; ?> டோக்கர் அமைப்பில்

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

டோக்கர் அமைப்பில் காஃப்காவுடனான ஸ்பார்க் தொழிலாளி இணைப்புச் சிக்கல்களைத் தீர்ப்பது
டோக்கர் அமைப்பில் காஃப்காவுடனான ஸ்பார்க் தொழிலாளி இணைப்புச் சிக்கல்களைத் தீர்ப்பது
Daniel Marino
திங்கள், 9 டிசம்பர், 2024 ’அன்று’ பிற்பகல் 8:20:49

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

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

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

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

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

கட்டளை பயன்பாட்டின் உதாரணம்
from_json() இந்த Spark SQL செயல்பாடு JSON சரத்தை பாகுபடுத்தி கட்டமைக்கப்பட்ட தரவு பொருளை உருவாக்குகிறது. எடுத்துக்காட்டில், காஃப்கா செய்திகளை கட்டமைக்கப்பட்ட தரவுகளாக மாற்ற இது பயன்படுகிறது.
StructType() கட்டமைக்கப்பட்ட தரவு செயலாக்கத்திற்கான திட்டத்தை வரையறுக்கிறது. காஃப்கா செய்திகளின் எதிர்பார்க்கப்படும் வடிவமைப்பை வரையறுக்க இது மிகவும் பயனுள்ளதாக இருக்கும்.
.readStream காஃப்கா அல்லது பிற ஸ்ட்ரீமிங் மூலங்களிலிருந்து தொடர்ச்சியான தரவு உட்செலுத்தலை அனுமதிக்கும் ஸ்பார்க்கில் ஸ்ட்ரீமிங் டேட்டாஃப்ரேமைத் தொடங்குகிறது.
writeStream ஸ்பார்க் ஸ்ட்ரக்ச்சர்டு ஸ்ட்ரீமிங் வினவலுக்கான வெளியீட்டு முறை மற்றும் சிங்க் ஆகியவற்றை வரையறுக்கிறது. இங்கே, இணைப்பு பயன்முறையில் பணியகத்திற்கு எழுதுவதைக் குறிப்பிடுகிறது.
bootstrap_servers காஃப்கா தரகரின் முகவரியைக் குறிப்பிடும் காஃப்கா உள்ளமைவு அளவுரு. ஸ்பார்க் மற்றும் காஃப்கா தொடர்புக்கு முக்கியமானவை.
auto_offset_reset முன் ஆஃப்செட் இல்லாத போது செய்திகளை எங்கு படிக்கத் தொடங்குவது என்பதைத் தீர்மானிக்கும் காஃப்கா நுகர்வோர் அமைப்பு. "முந்தைய" விருப்பம் பழைய செய்தியிலிருந்து தொடங்குகிறது.
KAFKA_ADVERTISED_LISTENERS ஒரு டோக்கர் காஃப்கா உள்ளமைவு சூழல் மாறி. இது காஃப்கா வாடிக்கையாளர்களுக்கு விளம்பரப்படுத்தப்பட்ட முகவரிகளைக் குறிப்பிடுகிறது, டோக்கர் நெட்வொர்க்கிற்குள்ளும் வெளியேயும் சரியான தகவல்தொடர்புகளை உறுதி செய்கிறது.
KAFKA_LISTENERS உள்வரும் இணைப்புகளை காஃப்கா தரகர் கேட்கும் பிணைய இடைமுகங்களை உள்ளமைக்கிறது. உள் மற்றும் வெளிப்புற தொடர்புகளை பிரிக்க இங்கே பயன்படுத்தப்படுகிறது.
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP வெவ்வேறு காஃப்கா கேட்பவர்களுக்கான பாதுகாப்பு நெறிமுறைகளை வரையறுக்கிறது. இந்த விஷயத்தில் PLAINTEXT போன்ற, கேட்பவர் பெயர்களை அந்தந்த நெறிமுறைகளுக்கு இது வரைபடமாக்குகிறது.
.awaitTermination() ஸ்ட்ரீமிங் வினவல் முடிவடையும் வரை ஸ்கிரிப்ட்டின் செயல்பாட்டைத் தடுக்கும் ஒரு ஸ்பார்க் கட்டமைக்கப்பட்ட ஸ்ட்ரீமிங் முறை, ஸ்ட்ரீம் தொடர்ந்து இயங்குவதை உறுதி செய்கிறது.

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

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

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

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

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

ஸ்பார்க் தொழிலாளி மற்றும் காஃப்கா தரகர் இடையே இணைப்பு சிக்கல்களைக் கையாளுதல்

தீர்வு 1: டோக்கருடன் ஸ்பார்க் மற்றும் காஃப்காவில் உள்ள பிழைத்திருத்தம் மற்றும் இணைப்பு சிக்கல்களைத் தீர்க்க பைத்தானைப் பயன்படுத்துதல்

# 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()

டாக்கரைஸ் செய்யப்பட்ட காஃப்காவில் டிஎன்எஸ் ரெசல்யூஷன் சிக்கல்களை பிழைத்திருத்தம் செய்தல்

தீர்வு 2: சரியான DNS தெளிவுத்திறனுக்காக டோக்கர் கம்போஸ் உள்ளமைவை மாற்றுதல்

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

காஃப்கா நுகர்வோர் இணைப்பைச் சோதிக்கிறது

தீர்வு 3: இணைப்பைச் சோதிக்க பைதான் காஃப்கா நுகர்வோர்

# 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")` ஐச் சேர்ப்பது அதிக சுமைகளின் கீழும் திறமையான தரவு மீட்டெடுப்பை உறுதி செய்கிறது. நிகழ்நேரத்தில் பங்கு விலைகளைக் கண்காணிக்கும் ஒரு தயாரிப்பு-தர பயன்பாட்டை கற்பனை செய்து பாருங்கள் - தோல்வி-பாதுகாப்புகளை வைத்திருப்பது பிணைய விக்கல்களின் போதும் தடையற்ற தரவு ஓட்டத்தை உறுதி செய்கிறது. இந்த நுட்பங்கள் ஒன்றாக நம்பகமான தரவு செயலாக்க குழாயின் முதுகெலும்பாக அமைகின்றன. 🚀

டோக்கரில் ஸ்பார்க் மற்றும் காஃப்கா பற்றிய பொதுவான கேள்விகள்

  1. நோக்கம் என்ன KAFKA_ADVERTISED_LISTENERS?
  2. டோக்கர் நெட்வொர்க்கிற்கு உள்ளேயும் வெளியேயும் சரியான தகவல்தொடர்புகளை உறுதிசெய்து, காஃப்கா கிளையண்டுகள் இணைக்க விளம்பரப்படுத்தப்பட்ட முகவரிகளை இது குறிப்பிடுகிறது.
  3. டோக்கர் கம்போஸில் தனிப்பயன் நெட்வொர்க்கை எவ்வாறு வரையறுப்பது?
  4. இதன் கீழ் நீங்கள் ஒரு பிணையத்தைச் சேர்க்கலாம் networks விசை மற்றும் சேவைகளில் அதைச் சேர்க்கவும், `networks: my_network`.
  5. டோக்கர் கொள்கலன்களில் DNS தெளிவுத்திறன் ஏன் தோல்வியடைகிறது?
  6. கன்டெய்னர்கள் அவற்றின் DNSஐ இணைக்கும் ஒரே டோக்கர் நெட்வொர்க்கின் ஒரு பகுதியாக இல்லாவிட்டால், அவை ஒன்றையொன்று பெயரால் அடையாளம் காண முடியாது.
  7. பங்கு என்ன .option("subscribe", "topic") ஸ்பார்க் ஸ்ட்ரீமிங்கில்?
  8. இது நிகழ்நேர தரவு உட்செலுத்தலுக்காக குறிப்பிட்ட காஃப்கா தலைப்புக்கு ஸ்பார்க் கட்டமைக்கப்பட்ட ஸ்ட்ரீமிங் டேட்டாஃப்ரேமை சந்தா செலுத்துகிறது.
  9. மீண்டும் முயற்சிகள் எப்படி காஃப்கா-ஸ்பார்க் ஒருங்கிணைப்பை மேம்படுத்தலாம்?
  10. போன்ற கட்டமைப்புகளில் மீண்டும் முயற்சிக்கிறது max.poll.records, நிலையற்ற பிழைகளைக் கையாளவும், நிலையான தரவுச் செயலாக்கத்தை உறுதிப்படுத்தவும் உதவும்.

ஸ்பார்க் மற்றும் காஃப்கா ஒருங்கிணைப்பை எளிதாக்குதல்

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

நிதித் தரவு அல்லது IoT ஸ்ட்ரீம்களைக் கண்காணிப்பது போன்ற நிஜ-உலகப் பயன்பாட்டு நிகழ்வுகள், வலுவான உள்ளமைவுகளின் முக்கியத்துவத்தை எடுத்துக்காட்டுகின்றன. இங்கு பகிரப்பட்டுள்ள கருவிகள் மற்றும் ஸ்கிரிப்ட்கள் பொதுவான தடைகளை கடக்க மற்றும் திறமையான, நிகழ் நேர தரவு பைப்லைன்களை உருவாக்குவதற்கான அறிவை உங்களுக்கு வழங்குகின்றன. 🛠️

ஆதாரங்கள் மற்றும் குறிப்புகள்
  1. இந்த கட்டுரை அதிகாரியால் தெரிவிக்கப்பட்டது அப்பாச்சி ஸ்பார்க் காஃப்கா ஒருங்கிணைப்பு ஆவணம் , கட்டமைப்பு மற்றும் பயன்பாடு பற்றிய விரிவான நுண்ணறிவுகளை வழங்குகிறது.
  2. டோக்கர் நெட்வொர்க்கிங் சிறந்த நடைமுறைகள் குறிப்பிடப்பட்டன டோக்கர் நெட்வொர்க்கிங் ஆவணம் துல்லியமான மற்றும் நம்பகமான கொள்கலன் தொடர்பு அமைப்புகளை உறுதி செய்ய.
  3. நடைமுறை எடுத்துக்காட்டுகள் மற்றும் கூடுதல் காஃப்கா அமைப்புகள் இதிலிருந்து மாற்றியமைக்கப்பட்டன Wurstmeister Kafka Docker GitHub களஞ்சியம் .