cis_question_factory_prompt.txt

Here are real exam questions from a university course called "Cloud Information Systems":
**Question 1: AWS Lambda is an example of which cloud computing service model?** 
- [ ] Query as a Service (QaaS)
- [ ] Platform as a Service (PaaS)
- [ ] Software as a Service (SaaS)
- [x] Function as a Service (FaaS)

**Question 2: The architecture pattern of dividing an application/system into a suite of small services is called?** 
- [ ] Monolith
- [x] Microservice
- [ ] Lift-and-Shift
- [ ] Middleware

**Question 3: Which statements about Unikernel are true?** 
- [ ] Mac OS X is an example of a Unikernel
- [x] They are single-address space operating systems
- [ ] Unikernels are not suitable for the cloud, because we always run multiple services per VM
- [x] Their design is a lot less complex than traditional operating systems

**Question 4: Name two capital expenses (CAPEX) that should be considered in the TCO calculation of a data center.** 
- Data center (building)
- Server hardware (compute, storage, networking)

**Question 5: Compare the advantages and disadvantages of reserved instances and (instance family) savings plans. When should you use which?** 
- Both trade-off flexibility for price discounts
- Reserved instances can be sold on a marketplace, savings plans cannot
- Savings plan spending can be flexibly spread over the hour (i.e., for reserved instances, you pay for the instance; savings plan, you pay for compute)

**Question 6: DynamoDB: Explain the difference between strongly- and eventually-consistent reads.** 
- Strongly consistent reads: Reads that always return up-to-date data. In DynamoDB, strongly-consistent reads are served by the leader and therefore by definition up-to-date.
- Eventually consistent reads: Reads that may return stale data. In DynamoDB, eventually-consistent reads are served by a random storage node. Since DynamoDB only requires one additional node to acknowledge a write - the third node may temporarily lag behind. The ”eventually consistent” stems from the fact that the lagging node will at some point catch up and after repeating the read for some time the node will eventually return the correct value.

**Question 7: The following Python code for storing an object in S3 contains two errors. Explain the errors by referring to line numbers. (Hint: These are conceptual and not syntax errors)**
```python
1 import boto3
2
3 s3 = boto3.client('s3')
4 bucket_name = "cis-exam-bucket"
5 key_name = "key1"
6
7 s3.create_bucket(Bucket=bucket_name)
8 example = "Cloud Information Systems"
9 s3.put_object(Key=key_name, Bucket=bucket_name, Body=example)
```
Answer 7:

Line 3: Creation of client is missing
Line 9: PUT to S3 issued without specifying a bucket

**Question 8: Assuming a Read/Write ratio of 80/20: What is the cost of using the Object Storage for one month? Include the storage cost.**
Answer 8:

Storage cost: 2$/GB * 25GB = 50$
Read Cost: (0.8 * 1000000GET) * 0.01$/GET = $8000
Write Cost: (0.2 * 1000000PUT) * 0.05$/PUT = $10.000
Total: $18.050

**Question 9: Explain how we can use one (or a combination of multiple) AWS services to reduce the cost of storing and retrieving data.**
Answer 9:

(Since we don’t precisely define in what context we use the object store, the question is open to interpretation and multiple answers are acceptable)
Depending on durability guarantees, we could just store all data on an EC2 instance
Depending on data distribution, we may install a cache to avoid hitting the object store for hot objects
We can potentially batch PUT requests to reduce per request cost

######

Create five questions in the same style (not more than three multiple choice questions) about the following lecture notes:


**copy-paste slides here**