
Apache Kafka adalah platform streaming data terdistribusi yang digunakan untuk menangani data real-time dalam jumlah besar. Kafka sering digunakan untuk mengirim, menyimpan dan memproses data secara cepat antara sistem atau aplikasi yang berbeda.
🔹 Fungsi Utama Apache Kafka:
Publish dan Subscribe Pesan
Kafka bekerja seperti sistem message broker, di mana produsen (producer) mengirim data, dan konsumen (consumer) menerima data.
Penyimpanan Data Secara Terdistribusi
Kafka menyimpan data dalam bentuk log yang dapat diproses ulang kapan saja.
Pemrosesan Data Real-Time
Kafka dapat memproses data secara langsung menggunakan Kafka Streams atau teknologi seperti Apache Flink & Spark.
🔹 Komponen Utama Apache Kafka
Producer: Mengirim data ke Kafka (misalnya dari aplikasi, sensor, database)
Consumer: Menerima data dari Kafka untuk diproses
Broker: Server Kafka yang menyimpan data dan mengatur distribusi
Topic: Saluran tempat data dikirimkan, seperti kategori atau jenis data
Partition: Membagi data dalam satu topic untuk meningkatkan kecepatan dan skalabilitas
Zookeeper: Mengelola cluster Kafka dan menjaga koordinasi antar node
Kafka Producer memiliki beberapa fitur utama:
Asynchronous Messaging: Pesan dikirim secara asinkron untuk meningkatkan performa.
Message Batching: Producer dapat mengirimkan beberapa pesan dalam satu batch untuk efisiensi.
Serialization: Data dikonversi ke format yang dapat diproses oleh Kafka, seperti JSON atau Avro.
Acknowledgment (acks): Producer dapat mengonfirmasi apakah pesan telah diterima oleh Kafka.
Beberapa proses yang terjadi:
Mengambil data dari sumber eksternal seperti API atau database.
Memproses atau memformat ulang data agar sesuai dengan kebutuhan.
Mengirim data ke Kafka Topics, tempat penyimpanan sementara sebelum dikonsumsi oleh Consumer.
Menyebarkan data ke berbagai partisi dalam Kafka untuk load balancing dan parallel processing.
🔹 Cara Kerja Kafka (Alur Data)
1️⃣ Producer mengirim data ke Kafka Topic
2️⃣ Kafka menyimpan data di Brokers dalam bentuk partisi
3️⃣ Consumer membaca data dari Kafka
4️⃣ Data dapat diproses lebih lanjut atau disimpan dalam database
🔹 Contoh Penggunaan Apache Kafka
✅ Streaming Data Log & Monitoring (contoh: Logging server seperti ELK, Splunk)
✅ Proses Data Sensor IoT (contoh: Data dari smart devices)
✅ Pengolahan Data Finansial (contoh: Transaksi real-time di bank)
✅ Integrasi Microservices (contoh: Komunikasi antar layanan backend)
✅ Big Data Processing (contoh: Dengan Hadoop, Spark, atau Flink)
Sumber Data:¶
Menggunakan API dari https://randomuser.me/ yang akan mengenerate user secara acak
Parameter yang diambil hanya:
- Gender = Jenis kelamin
- Name = Nama (yang terdiri dari Titel, Nama Depan dan Nama Belakang)
- Nat = Kebangsaan
- Phone = Nomor telepon
Disusun dengan format Pretty JSON
import requests
url = "https://randomuser.me/api/?inc=gender,name,nat,phone&format=prettyJSON"
response = requests.get(url)
if response.status_code == 200:
data = response.json()
print(data) # Print the entire response
else:
print(f"Error: {response.status_code}")
{'results': [{'gender': 'female', 'name': {'title': 'Madame', 'first': 'Viviane', 'last': 'Vidal'}, 'phone': '078 338 23 37', 'nat': 'CH'}], 'info': {'seed': 'a36cbb9b0b403a9a', 'results': 1, 'page': 1, 'version': '1.4'}}
data
{'results': [{'gender': 'female',
'name': {'title': 'Madame', 'first': 'Viviane', 'last': 'Vidal'},
'phone': '078 338 23 37',
'nat': 'CH'}],
'info': {'seed': 'a36cbb9b0b403a9a',
'results': 1,
'page': 1,
'version': '1.4'}}
Merapihkan data yang akan digunakan
result = data['results'][0] # Get the first user
row_data = {
"Title": result['name']['title'],
"First Name": result['name']['first'],
"Nationality": result['nat'],
"Last Name": result['name']['last'],
"Gender": result['gender'],
"Phone": result['phone']
}
row_data
{'Title': 'Madame',
'First Name': 'Viviane',
'Nationality': 'CH',
'Last Name': 'Vidal',
'Gender': 'female',
'Phone': '078 338 23 37'}
Persiapan Data:¶
Kafka hanya menerima data dalam format byte string, sehingga kita perlu mengonversinya terlebih dahulu dengan tahapan:
- Mengonversi dictionary ke JSON (
json.dumps(row_data)). - Mengonversi ke format byte (
encode('utf-8')).
message = json.dumps(row_data).encode('utf-8')
message
b'{"Title": "Madame", "First Name": "Viviane", "Nationality": "CH", "Last Name": "Vidal", "Gender": "female", "Phone": "078 338 23 37"}'
Kafka Producer¶
Untuk membuat Kafka Producer di Python, kita akan menggunakan pustaka confluent_kafka untuk mengirimkan Random User ke Kafka. Sebelum mengirimkan data, kita perlu mengatur konfigurasi Producer terlebih dahulu.
Sebelum memulai, pastikan bahwa:
- Kafka sudah terinstal di sistem.
- Memiliki pustaka Python
confluent_kafka - Kafka sedang berjalan.
Sebelum menjalankan Kafka Producer, pastikan bahwa Kafka sudah berjalan di mesin kita. Untuk menjalankannya, kita gunakan sistem Docker Container, pada kesempatan ini digunakan Docker Desktop lokal.
1. Konfigurasi Server dan Port
Kafka Producer harus mengetahui alamat dan port dari Kafka Cluster agar dapat mengirim pesan. Konfigurasi ini dilakukan melalui bootstrap.servers, yang menentukan alamat broker Kafka yang akan digunakan untuk mengirimkan data.
Agar dapat mengirim data ke Kafka, kita harus membuat Kafka Producer dengan konfigurasi berikut:
bootstrap.servers: Menentukan alamat broker Kafka yang akan digunakan, pada kesempatan ini di localhost:9092client.id: ID unik untuk mengenali producer ini.
from confluent_kafka import Producer
KAFKA_CONFIG = {"bootstrap.servers" : "localhost:9092",
"client.id" : "random-user-producer"}
Selanjutnya, kita membuat instance Producer dengan konfigurasi yang telah ditentukan sebelumnya. Fungsi Producer() dari pustaka confluent_kafka digunakan untuk menginisialisasi producer Kafka yang akan mengelola koneksi dengan broker Kafka.
producer = Producer(KAFKA_CONFIG)
2. Topics and Message Structure (Key-Value Pair)
Kafka menyimpan pesan dalam Topics, yang berfungsi seperti "folder" tempat data dikelompokkan. Setiap pesan yang dikirimkan ke Kafka memiliki format Key-Value Pair, yang memungkinkan Kafka melakukan partisi data berdasarkan Key tertentu.
Mari kita tentukan topik Kafka serta interval pengiriman data:
TOPIC = 'random-user-topic'
INTERVAL = 30
3. Kirim Ke Kafka Producer
Setelah data siap, kita dapat mengirimkan pesan ke Kafka menggunakan
produce(TOPIC, message): Mengirimkan pesan ke topik Kafka.flush(): Memastikan semua data terkirim sebelum program selesai dieksekusi.
producer.produce(topic = TOPIC, value = message)
producer.flush()
0
Kafka Consumer¶
adalah komponen dalam Apache Kafka yang berfungsi untuk menerima dan membaca pesan yang dikirim oleh Kafka Producer melalui Kafka Topic.
Consumer bekerja dengan cara berlangganan (subscribe) ke satu atau lebih topic di Kafka dan membaca pesan yang masuk secara real-time.
🔹 Cara Kerja Kafka Consumer
1️⃣ Consumer berlangganan (subscribe) ke Topic
2️⃣ Kafka menyimpan data dalam partisi (partition)
3️⃣ Consumer membaca data berdasarkan offset (urutan pesan)
4️⃣ Kafka tidak akan menghapus data secara langsung, sehingga consumer dapat membaca ulang jika diperlukan
5️⃣ Jika ada banyak consumer dalam satu grup, Kafka akan membagi tugas membaca data secara otomatis
🔹 Komponen Utama Kafka Consumer
- Topic: Saluran tempat pesan dikirim
- Partition: Kafka membagi data ke dalam beberapa partisi untuk meningkatkan performa
- Offset: Posisi atau indeks pesan yang terakhir dibaca oleh consumer
- Consumer Group: Sekumpulan consumer yang bekerja bersama untuk membaca pesan dari Kafka
- Commit Offset: Kafka menyimpan informasi tentang pesan terakhir yang telah dibaca
🔹 Kafka Consumer Group
Consumer Group adalah kumpulan beberapa consumer yang membaca dari satu topic yang sama.
Kafka akan mendistribusikan partisi data secara otomatis ke setiap consumer dalam grup.
Jika ada lebih banyak consumer daripada partisi, beberapa consumer akan idle (tidak membaca data).
1️⃣ Server and Port Configuration
Sebelum membuat Consumer, kita perlu mengonfigurasikan beberapa parameter penting:
bootstrap.servers→ Menentukan alamat dan port broker Kafka yang digunakan untuk menerima data.group.id→ Mengelompokkan beberapa Consumer agar bisa membaca data secara bersamaan tanpa duplikasi.auto.offset.reset→ Mengontrol dari mana Consumer mulai membaca pesan:earliest→ Membaca dari awal jika belum ada offset yang disimpan.latest→ Membaca hanya pesan terbaru.
enable.auto.commit→ JikaTrue, Kafka akan otomatis menyimpan posisi offset. JikaFalse, kita perlu melakukan commit offset secara manual untuk lebih banyak kontrol.
Berikut konfigurasi dasarnya:
import pandas as pd
import json
from confluent_kafka import Consumer, KafkaException, KafkaError
pd.options.display.float_format = '{:,.3f}'.format
1. Konfigurasi Kafka Consumer
Sebelum dapat membaca data dari Kafka, kita perlu mengatur beberapa konfigurasi dasar untuk Kafka Consumer.
# Konfigurasi Kafka Consumer
consumer_config = {
"bootstrap.servers": "localhost:9092",
"group.id": "random-user-group",
"auto.offset.reset": "earliest"
}
2. Membuat Kafka Consumer
Setelah mengatur konfigurasi, kita perlu membuat objek Consumer yang akan digunakan untuk membaca data dari Kafka.
- Menggunakan
Consumer()menerima parameter berupa konfigurasi yang sudah kita definisikan sebelumnya (consumer_config). - Buat variabel
consumeryang akan digunakan untuk menerima data dari Kafka.
consumer = Consumer(consumer_config)
3. Subscribe ke Topik Kafka
Untuk mengakses data dari Kafka, kita perlu menentukan topik mana yang akan dibaca.
topic_name→ Nama topik yang ingin dibaca, dalam hal ini"bitcoin-topic".consumer.subscribe([topic_name])→ Memberitahu Kafka bahwa consumer ini ingin membaca pesan dari topik yang sudah ditentukan.
# Subscribe ke topik Kafka
topic_name = 'random-user-topic'
consumer.subscribe([topic_name])
Additional:
- Jika terdapat beberapa topik yang ingin dibaca, kita bisa memberikan daftar topik, misalnya:
consumer.subscribe(["topic1", "topic2"])
2️⃣ Fetch Data from Kafka
🔄 Polling Data dari Kafka
Kafka Consumer menggunakan metode poll(timeout) untuk menunggu dan mengambil data dari Kafka. Parameter timeout menentukan berapa lama Consumer akan menunggu pesan sebelum mencoba lagi.
msg = consumer.poll(timeout=1.0)
poll(timeout=1.0)→ Memerintahkan consumer untuk mengambil pesan dari Kafka dengan batas waktu 1 detik.- Jika ada pesan yang tersedia dalam antrean Kafka,
poll()akan segera mengembalikan pesan tersebut. - Jika tidak ada pesan dalam waktu yang ditentukan,
poll()akan mengembalikanNone.
msg
<cimpl.Message at 0x11eb41cc0>
- Kafka berhasil mengembalikan sebuah objek pesan (
Message) yang berisi data dari Kafka. cimpl.Messageadalah objek yang merepresentasikan pesan Kafka dalam libraryconfluent-kafka.0x11eb41cc0adalah alamat memori tempat objekMessageini disimpan (akan berbeda setiap kali dijalankan).
Jika ingin melihat isi pesan yang sebenarnya, kita bisa mentransform atau decode pesan dari bytes ke string
msg.value().decode('utf-8')
'{"Title": "Mrs", "First Name": "Rosalinde", "Last Name": "Greb", "Gender": "female", "Phone": "0948-7585689"}'
3️⃣ Process and Store Data
📝 Memproses Data yang Diterima
Setelah menerima pesan dari Kafka, kita perlu mengonversinya ke dalam format yang mudah digunakan. Di sini, kita akan menggunakan json.loads() untuk mengubah JSON menjadi dictionary Python.
1. Menyimpan Data dalam List
Sebelum memproses data, kita akan menyiapkan sebuah list kosong untuk menyimpan data Bitcoin yang diterima dari Kafka.
# List awal untuk menyimpan data
random_user_data=[]
2. Parsing Data JSON dari Kafka
Ketika kita menerima pesan dari Kafka, pesan tersebut biasanya dalam format JSON. Oleh karena itu, kita perlu mengonversi pesan tersebut ke dalam bentuk dictionary Python menggunakan json.loads().
# Parsing data
random_user_data_point = json.loads(msg.value().decode('utf-8'))
json.loads(): Mengonversi string JSON menjadi dictionary Python yang bisa kita akses lebih lanjut.
3. Menambahkan Data ke dalam List
Setelah kita mendapatkan data yang sudah diproses, kita akan menambahkannya ke dalam list random_user_data untuk menyimpan setiap titik data.
random_user_data.append(random_user_data_point)
4. Mengubah List Menjadi Dataframe untuk Analisis Lebih Lanjut
Setelah beberapa data terkumpul, kita bisa mengubah list tersebut menjadi sebuah Dataframe menggunakan pandas, yang memudahkan analisis lebih lanjut dan visualisasi data.
# Mengubah list menjadi DataFrame untuk analisis lebih lanjut
random_user_data_df = pd.DataFrame(random_user_data, columns=['Title', 'First Name', 'Last Name', 'Gender', 'Phone'])
random_user_data_df
| Title | First Name | Last Name | Gender | Phone | |
|---|---|---|---|---|---|
| 0 | Ms | Olivia | Woods | female | 021-018-1790 |
| 1 | Mrs | Ruby | White | female | (764)-202-1525 |
| 2 | Mr | Koray | Topaloğlu | male | (154)-087-8658 |
| 3 | Mr | Adam | Johansen | male | 40788322 |
| 4 | Miss | Camila | Johnson | female | 08-2096-6197 |
| 5 | Mr | Liam | Hall | male | (403)-562-3085 |
| 6 | Mr | Noah | Robinson | male | (048)-480-8057 |
| 7 | Mr | Augustin | Richard | male | 03-78-56-50-51 |
| 8 | Mr | Barış | Tekand | male | (143)-511-3515 |
[Tambahan]
Menghitung jumlah masing-masing jenis kelamin user yang muncul untuk dibuatkan line plot sederhana
# Count occurrences of each gender
gender_counts = random_user_data_df['Gender'].value_counts()
display(gender_counts)
Gender male 6 female 3 Name: count, dtype: int64
🖥️ Display Real-time Data
Karena kita ingin memantau data secara real-time, kita perlu memperbarui DataFrame secara terus-menerus dengan polling data dari Kafka. Dalam hal ini, kita akan menggunakan loop yang berjalan terus-menerus dan memperbarui tampilan di Jupyter Notebook dengan pembaruan data secara real-time.
try, except, dan finally¶
Blok try-except-finally digunakan untuk menangani error atau pengecualian (exception) yang mungkin terjadi saat menjalankan kode. Struktur ini membantu program untuk tetap berjalan meskipun ada error dan untuk memastikan kode tertentu dieksekusi, terlepas dari apakah error terjadi atau tidak.
Struktur General try, except, dan finally
try: Di dalam blok ini, kita menulis kode yang mungkin menyebabkan error. Jika error terjadi, eksekusi kode akan berpindah ke blokexcept.except: Blok ini menangani error yang terjadi dalam bloktry. Kita dapat menentukan jenis error tertentu atau menangani semua jenis error. Jika ada error di bloktry, maka kode di dalamexceptyang sesuai dengan error tersebut akan dijalankan.finally: Blok ini dijalankan terlepas dari apakah ada error atau tidak. Biasanya digunakan untuk menutup file, melepaskan resource, atau menutup koneksi (seperti yang dilakukan denganconsumer.close()di contoh kita).
try:
# Diisi dengan kode yang mungkin menyebabkan error
pass # Misalnya, membuka file atau melakukan koneksi database
except ExceptionType:
# Diisi dengan kode untuk menangani error
pass # Menangani error tertentu (misalnya, FileNotFoundError)
finally:
# Diisi dengan kode yang ingin dijalankan terlepas dari apakah ada error atau tidak
pass # Menutup koneksi atau membersihkan resource
1️⃣ try
Di dalam blok try, kita akan memasukkan beberapa kode yang bertanggung jawab untuk menjalankan polling data dari Kafka dan memprosesnya sesuai dengan kebutuhan. Pada kasus ini, kita menambahkan loop polling, pemeriksaan error, parsing data, dan update tampilan real-time.
Secara umum, kode di dalam blok try akan terus dieksekusi selama tidak ada error yang terjadi. Jika ada error, maka eksekusi akan berpindah ke blok except.
Berikut adalah rincian kode yang akan dimasukkan ke dalam try:
while True:- loop yang terus berulang dan mengambil data dari Kafka secara terus-menerus.msg = consumer.poll(timeout=1.0)- Fungsi polling untuk menunggu pesan dari Kafka. Jika tidak ada pesan dalam waktu 1 detik, proses ini akan mengulang.if:if msg is None:- Jika tidak ada pesan yang diterima, program akan melanjutkan untuk mengecek pesan berikutnya.if msg.error():- Mengecek apakah ada error pada pesan. Jika error terkait dengan akhir partisi (_EOF), maka loop akan terus berjalan. Jika ada error lain, pesan error dicetak dan proses berhenti.
if:if "Gender" in random_user_df.columns:- Memastikan bahwa kolom "Gender" ada dalam DataFrame, Jika tidak ada, kode ini akan melewati blok selanjutnya untuk menghindari error.
if:if gender in gender_counts:- Memastikan gender yang diterima adalah yang dikenali (male/female), gender_counts adalah dictionary yang menyimpan jumlah "male" dan "female", jika nilai gender ditemukan dalam gender_counts, maka kita bisa menambah jumlahnya.
Pemrosesan data:
random_user_data_point = json.loads(msg.value().decode('utf-8'))- Mengonversi data yang diterima (yang berupa JSON) menjadi format dictionary Python.random_user_data.append(random_user_data_point)- Menambahkan data user yang baru ke dalam listrandom_user_data.random_user_df = pd.DataFrame(random_user_data)- Membuat DataFrame dari data yang telah diterima dan disimpan dalamrandom_user_data.gender = random_user_data_point.get("Gender", None)- random_user_data_point adalah data terbaru yang diterima dari Kafka dalam bentuk dictionary (JSON), .get("Gender", None) akan mengambil nilai dari key "Gender" dalam dictionary, jika key "Gender" tidak ditemukan, maka akan mengembalikan None.gender_counts[gender] += 1- Menambahkan jumlah kemunculan gender tersebutstep_counter += 1- Menambahkan step counter untuk tracking jumlah data yang masuk, step_counter bertindak sebagai sumbu X untuk grafik. Setiap kali data baru diterima, langkah (step_counter) akan bertambah.history["Step"].append(step_counter)- Menyimpan nomor langkah (jumlah total data yang masuk).history["male"].append(gender_counts["male"])- Menyimpan jumlah total "male" yang sudah diterima.history["female"].append(gender_counts["female"])- Menyimpan jumlah total "female" yang sudah diterima.update_plot()- Memanggil fungsi update_plot() untuk menggambar ulang grafik, fungsi ini memperbarui grafik gender count secara real-time, grafik akan menunjukkan bagaimana jumlah male dan female bertambah seiring waktu.
Kebutuhan display:
clear_output(wait=True)- Membersihkan output sebelumnya di Jupyter Notebook, agar tampilan data selalu terbarui tanpa membebani tampilan.plt.show()- Menampilkan plot, disini menggunakan data akumulasi Gender.display(random_user_df)- Menampilkan DataFrame yang berisi data user yang diterima secara real-time.time.sleep(1)- Memberikan jeda setengah detik sebelum memproses data berikutnya, agar tidak membebani notebook.
2️⃣ except¶
Pada bagian except, kita akan menangani error atau kejadian tertentu yang terjadi selama eksekusi kode dalam blok try. Dalam hal ini, kita akan menangani error KeyboardInterrupt, yang biasanya terjadi ketika pengguna menekan tombol Ctrl + C untuk menghentikan proses. Logika yang digunakan adalah, ketika tombol stop ditekan, maka program akan berhenti secara aman dan menampilkan pesan "Stopped by user".
except KeyboardInterrupt:
print("Stopped by user")
3️⃣ finally¶
Pada bagian finally, kita akan menambahkan kode yang harus dieksekusi terlepas dari apakah terjadi error atau tidak dalam blok try dan except. Pada kasus ini, kita akan menutup Kafka Consumer dengan cara memanggil consumer.close(), untuk memastikan koneksi dengan Kafka ditutup dengan aman saat program dihentikan.
Contoh kode:
finally:
consumer.close() # Menutup Kafka Consumer dengan aman
import pandas as pd
import json
from confluent_kafka import Consumer, KafkaError
import time
import matplotlib.pyplot as plt
from IPython.display import display, clear_output
pd.options.display.float_format = '{:,.3f}'.format
# Kafka Consumer Configuration
consumer_config = {
"bootstrap.servers": "localhost:9092",
"group.id": "random-user-group",
"auto.offset.reset": "earliest"
}
consumer = Consumer(consumer_config)
topic_name = 'random-user-topic'
consumer.subscribe([topic_name])
# Initialize gender counts and historical data
gender_counts = {"male": 0, "female": 0}
history = {"Step": [], "male": [], "female": []}
step_counter = 0 # Track steps for plotting
# Function to update the line plot
def update_plot():
plt.figure(figsize=(8, 5))
plt.plot(history["Step"], history["male"], marker='o', linestyle='-', label="male", color='blue')
plt.plot(history["Step"], history["female"], marker='s', linestyle='-', label="female", color='red')
plt.xlabel("Number of Additions")
plt.ylabel("Count")
plt.title("Gender Count Over Time")
plt.legend()
plt.grid(True)
clear_output(wait=True) # Clear previous output to refresh display
plt.show()
# List to store received data
random_user_data = []
# Kafka Consumer Loop
try:
while True:
msg = consumer.poll(timeout=1.0)
if msg is None:
continue
if msg.error():
if msg.error().code() == KafkaError._PARTITION_EOF:
continue
else:
print(f"Kafka Error: {msg.error()}")
break
# Parse JSON message from Kafka
random_user_data_point = json.loads(msg.value().decode("utf-8"))
random_user_data.append(random_user_data_point)
# Create DataFrame from collected data
random_user_df = pd.DataFrame(random_user_data)
# Check if "Gender" exists before counting
if "Gender" in random_user_df.columns:
# Count occurrences of each gender
gender = random_user_data_point.get("Gender", None)
if gender in gender_counts:
gender_counts[gender] += 1
step_counter += 1 # Increment step count
# Update history for plotting
history["Step"].append(step_counter)
history["male"].append(gender_counts["male"])
history["female"].append(gender_counts["female"])
# Update the plot
update_plot()
display(random_user_df)
time.sleep(1) # Delay to prevent excessive CPU usage
except KeyboardInterrupt:
print("Stopped by user")
finally:
consumer.close() # Safely close the Kafka consumer
| Title | First Name | Last Name | Gender | Phone | |
|---|---|---|---|---|---|
| 0 | Miss | Séléna | Chevalier | female | 03-52-65-47-12 |
| 1 | Madame | Annie | Gautier | female | 077 261 55 34 |
| 2 | Ms | Margot | Sanchez | female | 04-79-97-87-58 |
| 3 | Mr | Sami | Lagesen | male | 72407906 |
| 4 | Mrs | Alexis | Taylor | female | (473)-412-5992 |
| 5 | Mr | Nathaniel | Brown | male | (949)-969-3801 |
| 6 | Mr | Eemeli | Puro | male | 02-941-346 |
| 7 | Miss | Hiske | Broeken | female | (008) 4487509 |
| 8 | Mr | Vedat | Mayhoş | male | (628)-984-5521 |
| 9 | Mr | Andreas | Christiansen | male | 85819190 |
| 10 | Ms | Laura | Møller | female | 90242902 |
| 11 | Mr | Kevin | Hart | male | (439) 584-1344 |
| 12 | Mr | Mijat | Srećković | male | 030-3797-758 |
| 13 | Mr | پوریا | رضاییان | male | 067-22401238 |
| 14 | Mr | Joey | Burton | male | 013873 56847 |
Stopped by user