What are the core components for a Big Data Streaming application?
6406531888224.
Data needs to be retrievable from a persistent store that supports message
replay. Replay refers to being able to fetch a specific set of data from that persistent store on-
demand., where the data is chosen based on filters usually defined on sequence numbers or
timestamps
6406531888225.
Data processing needs to be splittable across machines using divide-and-
conquer, and composable into steps that execute very quickly
6406531888226.
Hadoop needs to be setup for its big data capabilities
6406531888227.
The application needs to have the cloud-native properties of being resilient,
manageable and observable
6406531888228.
Application needs to be deployable on public cloud natively using PaaS
components
A published solution is not available for this question yet.
A big data streaming application that reads from using Kafka as source is observed to be really
slow. The Kafka cluster has 2 broker nodes and this application is reading from 1 topic that has 10
partitions. On closer investigation, it was found that Kafka is not scaling to the velocity of input
data coming in. How will you scale Kafka further?
6406531888234.
Increase memory in each of the brokers in the cluster
6406531888235.
Add disks to each broker in the cluster
6406531888236.
Add new brokers to the cluster
6406531888237.
Create more topics and change input application to reroute data to all topics to
be able to spread input data better
6406531888238.
Double the number of partitions for this single topic to be able to spread input
data better
A published solution is not available for this question yet.
You are given the task of improving the performance of a Spark SQL program. You suspect that
the culprit is the main transformation job in the program. When you run EXPLAIN on that SQL, you
see that Spark wrongly estimates that there are only 10 values for the key being aggregated,
whereas in reality the underlying data has a million values for that key. What actions would you
perform from the below to ensure that the right estimates are used?
6406531888239.
Create all tables as native Spark SQL tables (i.e. available as CatalogTables).
6406531888240.
Partition all tables on the same key on which the aggregate is happening.
6406531888241.
Ensure cost based optimizer (CBO) is ON.
6406531888242.
Run ANALYZE on all tables.
6406531888243.
Cache the table in a step with actions ahead of the SQL statement that is the
culprit.
A published solution is not available for this question yet.
What happens when a Spark Structured Streaming pipeline operating with Kafka as source is
subject to a machine failure?
6406531888229.
The data being processed when the failure happened will have produced
partial results that result in incorrect outputs.
6406531888230.
The pipeline will not be restarted automatically.
6406531888231.
The pipeline will be restarted automatically by Spark which is able to pick up
the exact data from Kafka which was being processed at the time of error
6406531888232.
Spark will throw an error and halt
6406531888233.
Spark will gracefully shut down, reboot that machine which failed and start the
Structured Streaming pipeline again to continue from where it left off
A published solution is not available for this question yet.
A company with headquarters (HQ) in the Middle East operates on a Sunday-Thursday weekday
schedule with Friday & Saturday as weekend days. It computes end of week revenue numbers by
first computing sales for each day at 1AM local time of the next day, and then summing up the
weekly sales every Sunday early morning at 3AM local time. This number gets reported to
leadership every Sunday morning 9AM local time. As a result of management change, it has
decided to relocate its HQ to India. Which of the following changes will need to be done to its ETL
pipeline?
6406531888244.
No change to business time since that remains constant at 1AM local time,
only the schedule for the final weekly sum operation needs to be changed to the operational time
of Monday 3AM India time instead of Sunday 3AM Middle East time.
6406531888245.
Since time zone has changed as well as week definition too, the definition of
business time has changed. So, the ETL has to be rewritten entirely.
6406531888246.
Nothing needs to change since daily sales is available at 1AM Middle East time
which is anyway behind India time and so the numbers will be available before leadership comes
in at 9AM.
6406531888247.
Event time has changed since the event of week ending has changed in
definition, and so the ETL needs to be changed to consider the new event in the data.
6406531888248.
No change required.
A published solution is not available for this question yet.
You are appointed as a Data Engineer in a company that has a legacy reporting application written
in Java which suffers from both performance and maintainability problems. The reporting
application plots dashboards with near real-time refresh (once every minute) of key business
indicators to help management take live decisions. The application reads data directly from the
source database of MongoDB, aggregates using simple counts and shows them visually in a UI.
The performance problem of this application comes because the source database is at times
overloaded and therefore the dashboard is not able to refresh fast enough. The maintainability
issue is because every time a new KPI summary is required, the source has to be changed to
include it. Choose from the options below the option that best tackles both problems:
6406531888249.
Since MongoDB is OLTP, it is not able to support business reporting. So,
replace it with Hadoop which supports OLAP better
6406531888250.
Extract raw data from MongoDB using Change Data Capture (CDC) once every
minute into Kafka, and then use Spark Streaming to compute the KPIs and then populate into a
NoSQL DB like Redis for the UI to consume.
6406531888251.
Convert the application from using plain Java to using Spark Streaming in Java
6406531888252.
Query MongoDB every 1 minute for new data using a check on document
inserted timestamp, use Spark Streaming to compute the KPIs with the queried data, and then
populate into a NoSQL DB like Redis for the UI to consume.
A published solution is not available for this question yet.
Dhoni is on the crease with a bat in hand that has sensors embedded throughout. The sensors talk
to the spider cam every second. The spider cam is itself a powerful ARM-based computer which
has connectivity to the cloud through the wire on which it hangs. Using this connectivity, it can
send as much or as little data as required and also receive instructions from the cloud. There is a
machine learning model which suggests to the batsman to loosen the grip on his bat or tighten it
based on the shots played using the sensor measurements. The way the suggestion happens is
using dynamic vibration intensity communicated to the sensors embedded in the bat handle. Your
task is to design the data pipeline that enables such feedback to Dhoni ideally before every ball
with as much accuracy as possible throughout the match. Which of the following options best
satisfies the requirements?
6406531888253.
Ingest all data into Pub/Sub, process using Google Cloud Dataflow, invoke the
ML model, and then write back output from Cloud to the spider cam to relay to the bat.
6406531888254.
Compress the ML model to fit into the spider cam’s available resource, and
write pipelines to execute the model in the spider cam itself
6406531888255.
Compress the data in the spider cam every 5 seconds, write to Pub/Sub the
compressed data, invoke the ML model and then write back output from Cloud to the spider cam
to relay to the bat.
6406531888256.
Compress the ML model to fit into the spider cam’s available resource, and
write pipelines to execute in the spider cam itself, with periodically data being sent to the cloud,
retrain the model using Google Cloud ML and then redeploy the model to the spider cam.
A published solution is not available for this question yet.
In the class, we saw the UDF for mobilenet_v2. By definition, UDFs are scalar. In Spark, there is
another class of user defined routines called UDAFs, which stand for User Defined Aggregator
Functions. UDAFs are meant to provide a means to write a custom aggregation function which
aggregates over a grouping of values to arrive at a single value. UDAF structure differs saliently
from UDFs in that it exposes the notion of a buffer as a way of maintaining intermediate state
before finalizing aggregate output. Why is a buffer required for UDAF and not for a UDF?
6406531888257.
A UDF is a scalar operation executing on 1 row at a time and producing output
immediately, and therefore there is no intermediate output necessary. Whereas, a UDAF operates
on multiple rows which will require multiple passes for the final output thereby requiring a buffer.
6406531888258.
A UDF is a scalar operation executing on many rows at a time, grouped by a
key and producing a single output, and therefore there is no intermediate output necessary.
Whereas, a UDAF operates on multiple rows which will require multiple passes for the final output
thereby requiring a buffer.
6406531888259.
A UDF is a scalar operation executing on 1 row at a time and producing output
immediately, and therefore there is no intermediate output necessary. Whereas, a UDAF operates
on multiple rows of unbounded size requiring a divide-and-conquer approach for computing
aggregates, which uses the intermediate buffer to store partial values before finalizing the result
aggregate.
6406531888260.
A UDF is a scalar operation executing on many rows at a time, grouped by a
key and producing a single output, and therefore there is no intermediate output necessary.
Whereas, a UDAF operates on multiple rows of unbounded size requiring a divide-and-conquer
approach for computing aggregates, which uses the intermediate buffer to store partial values
before finalizing the result aggregate.
A published solution is not available for this question yet.
In the class, we saw the UDF for mobilenet_v2. Specifically, the predict() function contained the
below lines of code
Why are these lines important in that pipeline of categorizing flowers?
6406531888261.
They check the syntax of the model function so that there are no errors
6406531888262.
They load the model into memory so that the loop iteration over each image
does not need to do the same operation again and again given model load times are prohibitively
expensive for DL models
6406531888263.
They invoke PyTorch libraries that have already been setup for model scoring
on GCP using APIs embedded within the function
6406531888264.
They are Map-style UDFs that make it an embarrassingly parallel computation
thus making the execution parallelized and fast.
A published solution is not available for this question yet.
You are given a Spark Streaming pipeline that invokes a pre-trained DL model for every image it
receives as input and produces the classification result in quick time. The model with the best
recall rate from the PyTorch library takes 3.1 seconds on an average to execute on a Quad CPU
Spark worker machine. However, the output is expected to be produced consistently within 3
seconds from having received the input. What is the best option to meet the expectations without
compromising on false negatives and minimizing the amount of money & effort that is spent
further?
6406531888265.
Use a different DL model that is faster but has half the recall rate.
6406531888266.
Build a custom model that compresses the highest recall rate model just
enough to be able to execute within the stipulated time, and measure recall.
6406531888267.
Parallelize the DL model code using Divide-and-Conquer so that it runs faster.
6406531888268.
Change Spark machine to use GPUs
A published solution is not available for this question yet.
Which of the following code snippets will give a runtime error? (Note: df is a spark dataframe. It
has a column called content which has images represented as byte array)
Consider a Structured Streaming application running on Google Dataproc firing up every 10
seconds, consuming any number of records from Kafka available since last read, and emitting
some computed answers to another Kafka topic. Consider also that apart from the functional
logic, the same application is also emitting into a file the start time and end time of every batch
invocation for audit purposes.
Assume there is a failure in one of the Dataproc machines that results in a failure of a specific run.
For the external world (i.e. anybody consuming the outputs of this application), will they see the
effect of the failure at all, or will it be as though there was no failure? Select the ones from the list
below that answer this question.
6406531888280.
Yes, the failure is visible. The only visible effect for the external world would be
in the form of a slowdown in runtime for completion of that batch as Structured Streaming retries
the batch that failed thus taking twice as much time as normal.
6406531888281.
Yes, the failure is visible because the side effect of emitting timestamps in a
batch will be visible as 2 consecutive Start timestamps without any end timestamp as Structured
Streaming retries the failed batch.
6406531888282.
No, no failure is visible since Structured Streaming uses transactions and
idempotence to achieve exactly-once processing.
6406531888283.
No, no failure is visible since Structured Streaming can process the same data
in a retry resulting in the same outputs again.
A published solution is not available for this question yet.
Let us say we are using structured streaming for continuously reading data from Kafka and
storing the results back into a Kafka topic. Now, instead, we decide that we need to just perform a
one-time batch operation, where there is a need to read specific data from Kafka (i.e. using pre-
determined offsets). How will we need to modify the code to make it work?
6406531888284.
The read and write commands will remain the same, but the remaining code
will need to be modified, as operations on streaming dataframes are not supported on static
dataframes.
6406531888285.
Only the read and write commands need to be modified to specify that it's a
batch operation.
6406531888286.
The entire code will need to be modified as the APIs for stream and batch
processing are completely different.
A published solution is not available for this question yet.
Consider a Kafka system that has two brokers with the exact same specifications. Let’s consider a
topic A with a single partition, whose two copies are being maintained by Kafka. Consider the
following cases:
Case 1: Both the copies reside in the same broker
Case 2: Each broker has one copy of the partition
Two of the key promises of Kafka are:
(i) Availability
(ii) Throughput
Regarding which of the above promises, case 1 is at a disadvantage as compared to case 2?
6406531888287.
Only (i)
6406531888288.
Only (ii)
6406531888289.
Both (i) and (ii)
6406531888290.
Neither (i) nor (ii)
A published solution is not available for this question yet.
Kubernetes is an open-source system for automating deployment, scaling and management of
containerized applications. Google Datastore and HBase are both highly-scalable NoSQL database
systems for interactive, real-time applications. Consider the following pipeline choices for effecting
the same outcome:
(i) Java producer on VM on GCP → Kafka VM on GCP → Spark Streaming on Hadoop VMs on GCP →
HBase on same Hadoop VMs on GCP
(ii) Java producer in Google Cloud Function → Pub/Sub → Dataflow → Datastore
(iii) Java producer in Kubernetes on GCP → Pub/Sub → Spark Streaming on Google Dataproc →
Datastore
(iv) Java producer on VM on GCP → Pub/Sub → Dataflow → Datastore
(v) Java producer in Kubernetes on GCP → Kafka VM on GCP → Spark Streaming on Hadoop VMs
on GCP → HBase on same Hadoop VMs on GCP
Which option below represents the correct order of pipeline options that has the “most IaaS” entry
to the left and the “most PaaS” entry to the right?
6406531888291.
(i), (v), (iii), (iv), (ii)
6406531888292.
(i), (ii), (iii), (iv), (v)
6406531888293.
(ii), (iii), (i), (iv), (v)
6406531888294.
(v), (iii), (i), (iv), (ii)
6406531888295.
All are equally PaaS / IaaS
A published solution is not available for this question yet.
Since it is the onset of summer, there is a surge in railway ticket bookings. The business head at
IRCTC is interested in a real-time view of what are the top 10 destinations being booked in
descending order of count of tickets purchased where port of origin is one of the tier-1 urban
centres such as Mumbai, Delhi, Chennai etc. She wants to see this be presented in a monitor
mounted in her office wall that refreshes with the latest info on an India map every 1 minute along
with the time of update so that she gets the confirmation that this is the latest data, so that she
can plan for new summer-special trains as required. What solution option below best solves for
the need?
6406531888304.
Route a copy of the ticket purchase to a Kafka topic, use Spark Structured
Streaming to continuously read from this topic and update the aggregates by destinations, and
emit using output mode “Update”.
6406531888305.
Route a copy of the ticket purchase to a Kafka topic, use Spark Structured
Streaming to periodically read from this topic every 1 minute and update the aggregates by
destinations, and emit top aggregates using the output mode “Complete”.
6406531888306.
Route a copy of the ticket purchase to a Kafka topic, use Spark Structured
Streaming to periodically read from this topic every 1 minute and count the destinations in that
batch, and emit only top aggregates in that batch using the output mode “Append”.
A published solution is not available for this question yet.
A Spark Streaming application is configured to execute once per minute. However, each run takes
10+ minutes consistently resulting in a never-ending backlog of work. The code in a nutshell looks
as follows:
You are given a Spark program that runs on a Google Dataproc cluster on a daily schedule from
1AM-12PM to produce as output the total amount of purchases made by every customer the
previous day. The data is coming into GCS every minute from a variety of sources as standalone
files. Therefore, the business leader now feels that having to wait till 12PM the next day is no
longer acceptable and instead wants approximate purchase information for each customer at
least every hour. What’s more, she wants to control the computation of the outcome completely
with flexibility to change the schedule as she wishes without the need for you or any other
developer to be involved. Which amongst the below represents the best option to achieve the
above?
6406531888300.
Change the code to assume hourly data instead of daily data, change
scheduler to run every hour & let her manage the execution of the code on Dataproc
6406531888301.
Change the code to leverage Spark Streaming with streaming window as “1
hour”, & let her manage the execution of the code on Dataproc
6406531888302.
Change the code to leverage Spark Streaming with streaming window as “1
hour”, convert from Dataproc to Dataflow, & let her manage the execution of the code on
Dataflow
6406531888303.
Write a Cloud Function to move all incoming per-minute standalone files from
GCS to Pub/Sub, change the code to leverage Spark Streaming with streaming window as “1 hour”,
convert from Dataproc to Dataflow, point source to Pub/Sub, & let her manage the execution of
the code on Dataflow
**Design Thinking**
**Section Id :** 64065338362
**Section Number :** 15
**Section type :** Online
**Mandatory or Optional :** Mandatory
A published solution is not available for this question yet.