DevOps Questions & Exercises

with cat_food as (
Select Customer_ID, SUM(Price) as TOTAL_PRICE
From Orders
Where Item like "%Cat Food%"
Group by Customer_ID
)
Select Customer_name, TOTAL_PRICE
From Customers c
Inner JOIN cat_food f
ON c.Customer_ID = f.Customer_ID
where c.Customer_ID in (Select Customer_ID from cat_food);

Although this was a simple statement, the "with" clause really shines when a complex query needs to be run on a table before joining to another. With statements are nice, because you create a pseudo temp when running your query, instead of creating a whole new table.

The Sum of all the purchases of cat food weren't readily available, so we used a with statement to create the pseudo table to retrieve the sum of the prices spent by each customer, then join the table normally.

It's a monitoring service that provides threat protection across all of the services in Azure. More specifically, it:

• Provides security recommendations based on your usage
• Monitors security settings and continuously all the services
• Analyzes and identifies potential inbound attacks
• Detects and blocks malware using machine learning

Azure AD is a cloud-based identity service. You can use it as a standalone service or integrate it with existing Active Directory service you already running.

Authentication is the process of identifying whether a service or a person is who they claim to be. Authorization is the process of identifying what level of access the service or the person have (after authentication was done)

The Elastic Stack consists of:

• Elasticsearch
• Elastic Hadoop
• Kibana
• Logstash
• Beats
• APM Server

The most used projects are the Elasticserach, Logstash and Kibana. Also known as the ELK stack.

1. The data logged by the application is sent to Elasticsearch
2. Elasticsearch stores the document it got and the document is indexed for quick future access
3. Logstash processes the data
4. The user creates visualizations which uses the index in elasticsearch and more specifically the data there (this is done in Kibana).
5. The user creates a dashboard which composed out of the visualization created earlier

From the official docs:

"Elasticsearch is a distributed document store. Instead of storing information as rows of columnar data, Elasticsearch stores complex data structures that have been serialized as JSON documents"

Index in Elastic is in most cases compared to a whole database from the SQL/NoSQL world.
You can choose to have one index to hold all the data of your app or have multiple indices where each index holds different type of your app (e.g. index for each service your app is running).

The official docs also offer a great explanation (in general, it's really good documentation, as every project should have):

"An index can be thought of as an optimized collection of documents and each document is a collection of fields, which are the key-value pairs that contain your data"

From the official docs:

"An inverted index lists every unique word that appears in any document and identifies all of the documents each word occurs in."

Continuing with the comparison to SQL/NoSQL a Document in Elastic is a row in table in the case of SQL or a document in a collection in the case of NoSQL. As in NoSQL a Document is a JSON object which holds data on a unit in your app. What is this unit depends on the your app. If your app related to book then each document describes a book. If you are app is about shirts then each document is a shirt.

False.

From the official docs:

"Each indexed field has a dedicated, optimized data structure. For example, text fields are stored in inverted indices, and numeric and geo fields are stored in BKD trees."

• _index
• _id
• _type

• You can optimize fields for partial matching
• You can define custom formats of known fields (e.g. date)
• You can perform language-specific analysis

An index is split into shards and documents are hashed to a particular shard. Each shard may be on a different node in a cluster and each one of the shards is a self contained index.
This allows Elasticsearch to scale to an entire cluster of servers.

Term Frequency is how often a term appears in a given document and Document Frequency is how often a term appears in all documents. They both are used for determining the relevance of a term by calculating Term Frequency / Document Frequency.

From the official docs:

"In the query context, a query clause answers the question “How well does this document match this query clause?” Besides deciding whether or not the document matches, the query clause also calculates a relevance score in the _score meta-field."

"In a filter context, a query clause answers the question “Does this document match this query clause?” The answer is a simple Yes or No — no scores are calculated. Filter context is mostly used for filtering structured data"

• Input Plugins - how to collect data from different sources
• Filter Plugins - processing data
• Output Plugins - push data to different outputs/services/platforms

From the official docs:

"Kibana is an open source analytics and visualization platform designed to work with Elasticsearch. You use Kibana to search, view, and interact with data stored in Elasticsearch indices. You can easily perform advanced data analysis and visualize your data in a variety of charts, tables, and maps."

There are several possible answers for this question. One of them is as follows:

A small-scale architecture of elastic will consist of the elastic stack as it is. This means we will have beats, logstash, elastcsearch and kibana.
A production environment with large amounts of data can include some kind of buffering component (e.g. Reddis or RabbitMQ) and also security component such as Nginx.

DNS (Domain Name Systems) is a protocol used for converting domain names into IP addresses.
As you know computer networking is done with IP addresses (layer 3 of the OSI model) but for as humans it's hard to remember IP addresses, it's much easier to remember names. This why we need something such as DNS to convert any domain name we type into an IP address. You can think on DNS as a huge phonebook or database where each corresponding name has an IP.

In general the process is as follows:

• The user types an address in the web browser (some_site.com)
• The operating system gets a request from the browser to translate the address the user entered
• A query created to check a local entry of the address exists in the system. In case it doesn't, the request is forwarded to the DNS resolver
• The Resolver is a server, usually configured by your ISP when you connect to the internet, that responsible for resolving your query by contacting other DNS servers
• The Resolver contacts the root nameserver (aka as .)
• The root nameserver responds with the address of the relevant Top Level Domain DNS server (if your address ends with org then the org TLD)
• The Resolver then contacts the TLD DNS and TLD DNS responds with the IP address that matches the address the user typed in the browser
• The Resolver passes this information to the browser
• The user is happy :D

• A
• PTR
• MX
• AAAA

While an A record points a domain name to an IP address, a PTR record does the opposite and resolves the IP address to a domain name.

According to Martin Kleppmann:

"Many processes running on many machines...only message-passing via an unreliable network with variable delays, and the system may suffer from partial failures, unreliable clocks, and process pauses."

According to the CAP theorem, it's not possible for a distributed data store to provide more than two of the following at the same time:

• Availability: Every request receives a response (it doesn't has to be the most recent data)
• Consistency: Every request receives a response with the latest/most recent data
• Partition tolerance: Even if some the data is lost/dropped, the system keeps running

It's an architecture in which data is and retrieved from a single, non-shared, source usually exclusively connected to one node as opposed to architectures where the request can get to one of many nodes and the data will be retrieved from one shared location (storage, memory, ...).

• Resolve host by request to DNS resolver
• Client SYN
• Server SYN+ACK
• Client SYN
• HTTP request
• HTTP response

False. Server doesn't maintain state for incoming request.

It consits of:

• Request line - request type
• Headers - content info like length, enconding, etc.
• Body (not always included)

• GET
• POST
• HEAD
• PUT
• DELETE
• CONNECT
• OPTIONS
• TRACE

• 1xx - informational
• 2xx - Success
• 3xx - Redirect
• 4xx - Error, client fault
• 5xx - Error, server fault

HTTP is stateless. To share state, we can use Cookies.

TODO: explain what is actually a Cookie

SSH HTTP DHCP DNS ...

https://idiallo.com/blog/c10k-2016

Tell them how did you hear about them :D Relax, there is no wrong or right answer here...I think.

Some ideas (some of them bad and should not be used):

• Senior DevOps
• Manager
• Retirement
• Your manager

If you worked in this area for more than 5 years it's hard to imagine the answer would be no. It also doesn't have to be big service outage. Maybe you merged some code that broke a project or its tests. Simply focus on what you learned from such experience.

You know best your order just have a good thought if you really want to put salary in top or bottom....

Bad answer: I don't. Better answer: Every person has strengths and weaknesses. This is true also for colleagues I don't have good work relationship with and this is what helps me to create good work relationship with them. If I am able to highlight or recognize their strengths I'm able to focus mainly on that when communicating with them.

You know the best, but some ideas if you find it hard to express yourself:

• Diversity
• Complexity
• Challenging
• Communication with several different teams

You know the best :)

You can use and elaborate on one or all of the following:

• Passion
• Motivation
• Autodidact
• Creativity (be able to support it with some actual examples)

Connection Pool is a cache of database connections and the reason it's used is to avoid an overhead of establishing a connection for every query done to a database.

A connection leak is a situation where database connection isn't closed after being created and is no longer needed.

• Query for running queries and cancel the irrelevant queries
• Check for connection leaks (query for running connections and include their IP)
• Check for table locks and kill irrelevant locking sessions

"A data warehouse is a subject-oriented, integrated, time-variant and non-volatile collection of data in support of organisation's decision-making process"

A single data source (at least usually) which is stored in a raw format.

• Not suitable for frequent code changes and the ability to deploy new features
• Not designed for today's infrastructure (like public clouds)
• Scaling a team to work monolithic architecture is more challenging

Vertical Scaling is the process of adding resources to increase power of existing servers. For example, adding more CPUs, adding more RAM, etc.

Horizontal Scaling is the process of adding more resources that will be able handle requests as one unit

What is the problem with the following architecture and how would you fix it?

The load on the producers or consumers may be high which will then cause them to hang or crash.
Instead of working in "push mode", the consumers can pull tasks only when they are ready to handle them. It can be fixed by using a streaming platform like Kafka, Kinesis, etc. This platform will make sure to handle the high load/traffic and pass tasks/messages to consumers only when the ready to get them.

You can mention:

roll-back & roll-forward cut over dress rehearsals DNS redirection