DEV Community: Arie Bregman

How to prepare for DevOps & SRE interviews?

Arie Bregman — Thu, 02 Jan 2020 16:41:31 +0000

Note: the following is opinionated.
Note2: the most updated version of this post is located in my GitHub project

Skills you should have

Linux

Every DevOps Engineer should have a deep understanding of at least one operating system and if you have the option to choose then I would say it should definitely be Linux as I believe it's a requirement of at least 90% of the DevOps jobs postings out there.

Usually, the followup question is "How extensive should my knowledge be?" Out of all the DevOps skills, I would say this, along with coding, should be your strongest skills. Be familiar with OS processes, debugging tools, filesystem, networking, ... know your operating system, understand how it works, how to manage issues, etc.

Not long ago, I've created a list of Linux resources right here. There are some good sites there that you can use for learning more about Linux.

Coding

My personal belief is that any DevOps engineer should know coding, at least to some degree. Having this skill you can automate manual processes, improve some of the open source tools you are using today or build new tools & projects to provide a solution to existing problems. Knowing how to code = a lot of power.

When it comes to interviews you'll notice that the level of knowledge very much depends on the company or position you are interviewing for. Some will require you just to be able to write simple scripts while others will deep dive into common algorithms, data structures, etc. It's usually clear from the job requirements or phone interview.

The best way to practice this skill is by doing some actual coding - scripts, online challenges, CLI tools, web applications, ... just code :)

Also, the following is probably clear to most people but let's still clarify it: when given the chance to choose any language for answering coding tasks/questions, choose the one you have experience with! Some candidates prefer to choose the language they think the company is using and this is a huge mistake since giving the right answer is always better than a wrong answer, no matter which language you have used :)

I recommend the following sites for practicing coding:

Architecture and Design

This is also an important aspect of DevOps. You should be able to describe how to design different systems, workflows, and architectures. Also, the scale is an important aspect of that. A design which might work for a dozen of hosts or X amount of data, will not necessarily work well with bigger scale.

Some ideas for you to explore:

How to design and implement a CI pipeline (or pipelines) for verifying PRs, run multiple different types of tests, package the project and deploy it somewhere
How to design and implement secured ELK architecture which will get logs from 10,000 apps and will display the data eventually to the user
Microservices designs are also quite popular these days

I recommend going over the following GitHub projects as they are really deep-diving into System Design:

https://github.com/donnemartin/system-design-primer

Tools

Some interviews will focus on specific tools or technologies. Which tools? this is mainly based on a combination of what you mentioned in your C.V & those that are mentioned in the job posting and used in the company. Here are some questions I believe anyone should know to answer regarding the tools he/she is familiar with:

What the tool does? What it allows us to achieve that we couldn't do without it?
What its advantages over other tools in the same area, with the same purpose? Why did you choose to use it?
How it works?
How to use it?

Let's deep dive into practical preparation steps

Scenarios || Challenges || Tasks

This is a very common way to interview today for DevOps roles. The candidate is given a task which represents a common task of DevOps Engineers or a piece of common knowledge and the candidate has several hours or days to accomplish the task.

This is a great way to prepare for interviews and I recommend to try it out before actually interviewing. How? Take requirements from job posts and convert them into scenarios. Let's see an example:

"Knowledge in CI/CD" -> Scenario: create a CI/CD pipeline for a project.

At this point, some people ask: "but what project?" and the answer is: what about GitHub? it has only 9125912851285192 projects...and a free way to set up CI to any of them (also a great way to learn how to collaborate with others :) )

Let's convert another scenario:

"Experience with provisioning servers" -> Scenario: provision a server (to make it more interesting: create a web server).

And the last example:

"Experience with scripting" -> Scenario: write a script. Don't waste too much time thinking "what script should I write?". Simply automate something you are doing manually or even implement your own version of common small utils.

Start your own DevOps project

Starting a DevOps project is a good idea because:

It will make you practice coding
It will be something you can add to your resume and talk about with the interviewer
Depends on size and complexity, it can teach you something about design in general
Depends on adoption, it can you teach you about managing Open Source projects

Same here, don't overthink what your project should be about. Just go and build something :)

Sample interview questions

Make a sample list of interview questions on various topics/areas like technical, company, role, ... and try to answer them.
See if you can manage to answer them in a fluent, detailed way.

I've gathered "a couple" of questions here

Better yet, ask a good friend/colleague to challenge you with some questions. Your self-awareness might be an obstacle in objective self-review of your knowledge :)

Networking

For those who attend technical meetups and conferences, it can be a great opportunity to chat with people from other companies on their interviewing process. But don't start with it, it can be quite awkward. Say at least hello first... (:

Doing so can give you a lot of information on what to expect from an interview at some companies or how to how to better prepare.

Know your resume

It may sound trivial but the idea here is simple: be ready to answer any question regarding any line you included in your resume.
Sometimes candidates surprised when they are asked on a skill or line which seems to be not related to the position but the simple truth is: if you mentioned something on your resume, it's only fair to ask you about it.

Know the company

Be familiar with the company you are interviewing at. Some ideas:

What the company does?
What products it has?
Why its products are unique (or better than other products)? This can also be a good question for you to ask

Books

From my experience, this is not done by many candidates but it's one of the best ways to deep dive into topics like operating system, virtualization, scale, distributed systems, etc.

In most cases, you will do fine without reading books but for the AAA interviews (hardest level) you'll want to read some books and overall if you inspire to be better DevOps Engineer, books (also articles, blog posts) is a great way :)

Consider starting in non-DevOps position

While not a preparation step, you should know that landing DevOps as a first position can be challenging. No, it's not impossible but still, since DevOps covers many different practices, tools, ... it can be quite challenging and also overwhelming for someone to try and achieve it as a first position.

A possible path to becoming a DevOps engineer is to start with actually a different (but related) position and switch from there after 1-2 years or more.

Some ideas:

System Administrator - This is perfect because every DevOps Engineer should have a solid understanding of the OS and sysadmins know their OS :)
Software Developer/Engineer - A DevOps should have coding skills and this position will provide more than the required knowledge in most cases
QA Engineer - This is a more tricky one because IMHO there are less overlapping areas/skills with DevOps Engineer. Sure, DevOps engineers should have some knowledge about testing but usually, it seems their solid skills/background is mainly composed out of system internals and coding skills.

What to expect from a DevOps interview?

DevOps interviews can be very different. Some will include design questions, some will focus on coding, others will include short technical questions and you might even have an interview where the interviewer only goes over your resume and discussing your past experience.

There are a couple of things you can do about it so it will be a less overwhelming experience:

You can and probably should ask the HR (in some cases even the team lead) how the interview process looks like. Some will be kind enough to even tell you how to prepare.
Usually, the job posting gives more than a hint on where the focus will be and what you should focus on in your preparations so read it carefully.
There are plenty of sites that have notes or a summary of the interview process in different companies, especially big enterprises.

Don't forget to be an interviewer as well

Some people tend to look at interviews as a one-way road of "Determining whether a candidate is qualified" but in reality, a candidate should also determine whether
the company he/she is interviewing at, is the right place for him/her.

Do I care about team size? More specifically, do I care about being a one-man show or being part of a bigger team?
Do I care about work-life balance?
Do I care about personal growth and how it's practically done?
Do I care about knowing what are my responsibilities as part of the role?

If you do, you should also play the interviewer role :)

One Last Thing

Good luck :)

5 Open Source Projects That Will Make You Smile

Arie Bregman — Thu, 28 Nov 2019 22:50:02 +0000

Volkswagen CI

volkswagen - "Volkswagen detects when your tests are being run in a CI server, and makes them pass."

Remember the Volkswagen emissions scandal back in 2015? You know, the one where Volkswagen had software in their diesel engines that could detect when they were being tested and change the performance accordingly to improve results.
Shortly after the scandal, some developers thought it will be funny to have an open source project with a similar idea of "let's just fake good results whenever running tests" and the volkswagen project is the outcome.

As you know, CI is the practice of testing and integrating your code often. When submitting a code that breaks your service, the CI pipeline will prevent it from being merged. That's a real bummer for people who write bad code. But fear no more, installing the Volkswagen project on the CI server will make the CI always pass, just like the software Volkswagen installed.

Bash Insulter

bash-instuler - "Insults the user when typing wrong command"

If you ever used the command line you know that doing mistakes is inevitable. At some point, you will either misspell some words or miss some characters. But that's fine, right? well not according to the bash-insulter project.

This project insults the user whenever he/she types a wrong command. Some of the insults are:

"This is why nobody likes you"
"So, I'm just going to go ahead and run rm -rf / for you."
"This is not a search engine."
"This is why you get to see your children only once a month." (this is where it escalates too quickly in my opinion)

The full list of insults that were contributed by multiple contributors can be found here. It's always heartwarming to see how the community works together to make the world a better place.

Thanos JS

thanos-js - "A casual (but dangerous) package that will let Thanos snap fingers and delete random files inside a directory"

Whether you are a Marvel fan or not, you probably have watched the Avengers movies or at least heard about them. In the last two Avengers movies, the main villain is a purple being called Thanos. And Thanos is a true believer in balance. He believes that overpopulation can, and should, be fixed by wiping out half of the galaxy population.
Whether he manages to do that or not is something I will not reveal here, to not spoil the ending to anyone (although it's a Marvel Disney movie, what do you think happened?...)

Anyway, Thanos was a true hero for many people and a great inspiration. This inspiration led to great (and very useless) projects like thanos-js

thanos-js will remove exactly half of the files on your computer. Each file is given a chance to be part of the 50% removed files or the 50% lucky untouched files. Eventually, you'll have a perfectly balanced system, like all systems should be. Assuming it will still run...

Bullshit.js

bullshit.js

Don't let the name of the project to fool you. This project is no bullshit. It has a mission-critical purpose of translating marketing-speak into human-readable text. In this case, a demo worth thousands of words: https://mourner.github.io/bullshit.js

Pizza-Dough

pizza-dough - "This recipe is dedicated to helping you make the best possible pizza dough for Neapolitan pizza"

The pizza-dough is actually a very serious project. I mean, just show me a more scientific, serious and accurate source for making pizza dough. And that's also exactly why it's amusing. Who would imagine that through the effort of pull requests and issues, we'll get possibly the best pizza recipe to date.
It seems like open source recipes are the next big thing (and remember where you first read it).

It's also good that GitHub now preserves open source code in an Arctic vault. Humanity will need this Pizza dough recipe in the post-apocalyptic era.

More open source projects that will make us smile :)

That's it. I hope you enjoyed this post. Very different from what I'm usually writing about, but for me, it was fun :)
If you know about other open source projects that will make us smile, let us know in the comments.

Collection of Linux Resources

Arie Bregman — Tue, 26 Nov 2019 16:00:04 +0000

Below, you'll find a collection of Linux resources categorized into resource types - videos, books, sites, etc. I hope it will serve you well in your journey of becoming a Linux Master ;)

For the most updated version of this page, please visit here

Learn Linux Sites for Beginners

Name	Description
Linux Journey	Guides ordered by topic with exercises
Techmint Linux	written articles/lessons
Linux Survival	Interactive guide
Linuxcommand	Learn the ways of the command line
Ryanstutorials	written guides for beginners
Vim Adventures	Learn how to use Vim by playing a game
LYM	Focuses on the command line. While it's great, I wouldn't start from it

Linux Videos

Video	Level
The Complete Linux Course: Beginner to Power User!	Beginner
learnlinux.tv	All
The Linux Basics Course	Beginner
The Complete Linux Course: Beginner to Power User!	Beginner
Learning the Linux File System	Beginner
Linux Hands On: The Advanced Terminal Commands	Beginner...name is misleading
10 Linux Interview Questions	Beginner
Unix System Calls	Advanced

Blogs & News sites

Name	Comments
Phoronix	News
nixCraft	Blog, Linux Tips, Hacks, Tutorials
thegeekstuff	Blog on Linux, Open Source and other topics
Brendangregg	Blog which focuses on Linux Performances
Enable Sysadmin	Red Hat blog which focuses on Linux System Administration

Linux Books

Title	Comments
The Linux Command Line	Free. Great for learning the command line
Linux Bible	Not Free, covers many beginner and advanced topics
A Practical Guide to Linux Commands, Editors, and Shell Programming	Not Free. Focusing on practical learning with many examples
Ubuntu Pocket Guide and Reference	There is a free version
Linux Bible	Not Free. Covers many beginner and also advanced topics
linux-training.be	Free. Little bit outdated (2015)
Modern Operating Systems	Not Free. Covers advanced topics. Deep dive into Linux Internals
Understanding the Linux Kernel	Not Free. Advanced. Deep dive into Linux kernel
Operating Systems: Three Easy Pieces	Great book on Operating System internals

Documentation

Title	Comments
Man pages	The online version of `man` command
The Linux Documentation Project	pure greatness

Linux Development Books

Title	Comments
Debugging with GDB: The GNU Source-Level Debugger	Not Free
Unix Network Programming	Not Free
Linux Kernel Development	Not Free

Forums and Communities

Name	Comments
linuxquestions.org
unix.stackexchange.com
askubuntu.com
Reddit Linux
Linux.org
Reddit Commandline	Not exclusive to Linux command line

Online Courses (Not Free)

Name	Description
Linux Academy	great courses. pay yearly or monthly
Udemy	payment per course

Random

Name	Comments
Kernel.org	Linux Kernel archives
GamingOnLinux	Gaming on Linux
DistroWatch	Discussions and reviews of Linux distributions
DistroTest	Test a distro online before actually using it
Linux From Scratch	For crazy people who would like to build a custom Linux :)
KaliTutorials	shhh...
explainshell	write down a command-line to see the help text that matches each argument
Unix Philosophy	Name says it all...
CommandlineFu	Great command-line gems

Linux Checklist for Beginners

Arie Bregman — Sat, 16 Nov 2019 00:04:16 +0000

File System Hierarchy

[ ] / (aka root)
[ ] /bin and /sbin
[ ] /opt
[ ] /usr
[ ] /var
[ ] /home
[ ] /etc
[ ] /proc
[ ] /tmp
[ ] Test
- [ ] What is '/'?
- [ ] What is stored in '/bin'? what about /etc?
- [ ] What '/home' is usually used for?
- [ ] What type of files can you find in '/var'?
- [ ] What is unique about /tmp?

Navigation

[ ] Commands
- [ ] pwd - where am I?
- [ ] cd - change directory
[ ] relative vs. absolute paths
[ ] Test
- [ ] How to check your current path?
- [ ] Where cd .. will take you?
- [ ] What would be the effect of running cd .?
- [ ] What will happen when running 'cd -'?

Files

[ ] Types of files
- [ ] Regular
- [ ] Directory
- [ ] Socket
- [ ] Character Device
- [ ] Block Device
- [ ] Link
- [ ] Named Pipe
[ ] Commands
- [ ] ls - list files and directories
- [ ] -a for listing hidden files
- [ ] -l for list formt
- [ ] -t order by time
- [ ] -F better distinguish between regular files and directories
- [ ] touch - creating files (original intention is updating timestamp)
- [ ] nice to know: touch file{1..5}
- [ ] rm - remove files
- [ ] -r for recursive
- [ ] -f to force removal, no questions asked
- [ ] mkdir - create directories
- [ ] -p - for creating multiple nested directories
- [ ] rmdir - remove directories
- [ ] cat - concatenate files (common usage: read a file)
- [ ] mv - move files directories (also rename files and directories)
- [ ] cp - copy a file
- [ ] -r for recursive (copy a directory)
- [ ] less - display files on a page-by-page basis
[ ] Test
- [ ] How to list hidden files?
- [ ] How to create an empty new file?
- [ ] How to remove a directory?
- [ ] How to rename a file?
- [ ] How to copy an entire directory with all its files?

Pattern Matching

This also known as File Globbing

[ ] Patterns
- [ ] * - matches zero or more of any character
- [ ] ? - matches one of any character

Commands

[ ] man - manual for commands
[ ] which - get full path for given command
[ ] whatis - one-line manual page descriptions
[ ] history - command history list
- [ ] use ![number line] to execute a command from the list

Random

[ ] Terminal
- [ ] clear - clear the terminal screen (ctrl+l can be also used)
- [ ] ctrl+r- history search of commands
- [ ] exit (or logout) - terminate a process, quit the shell
[ ] Commands
- [ ] echo - display a line of text
- [ ] alias - define or display command shortcuts/aliases
- [ ] wc - count lines, words, ...
[ ] Distributions
- [ ] Fedora
- [ ] Ubuntu
- [ ] RHEL, CentOS
- [ ] Mint
- [ ] Debian
- [ ] Arch Linux
- [ ] openSUSE

I/O redirection

[ ] File Descriptor
- [ ] stdin 0 (standard input) <
- [ ] stdout 1 (standard output) >
- [ ] stderr 2 (standard error) 2>
[ ] Append >>
[ ] Pipe
- [ ] For example: cat file | wc -l to count number of lines
[ ] tee
- [ ] Writing output to two different streams
- [ ] Test
[ ] How to redirect output?
[ ] What would be the result of the following command blop 2> file?

Text Editor

Learning how to use one of them is more than enough

[ ] vim
- [ ] i to start typing
- [ ] :wq to exit (or shit+zz)
[ ] nano
[ ] emacs
[ ] atom
[ ] sublime
[ ] Test (mainly for vim)
- [ ] How to remove an entire line?
- [ ] How to copy 5 lines?
- [ ] How to jump to the end of the line
- [ ] How to remove one word
- [ ] How to jump to the end of the file

Users

[ ] Types of users
- [ ] regular
- [ ] root
[ ] Commands
- [ ] useradd - add users
- [ ] usermod - modify users
- [ ] userdel - delete users
- [ ] who - show who is logged on
- [ ] lastlog - recent login of users
[ ] Files
- [ ] /etc/passwd - stores users information
- [ ] /etc/shadow - passwords
[ ] Test
- [ ] how to add a new user?
- [ ] should you be using your user or root?

Network

[ ] Commands
- [ ] ping - test the reachability of a host
- [ ] -c for number of packets
- [ ] ip - manage routing, network devices, interfaces and tunnels
- [ ] ip a for interfaces
- [ ] ip r for routing
- [ ] ip neigh for any ARP related operation
- [ ] ethtool - query and manipulate driver and hardware settings
- [ ] -p for interface led blinking
- [ ] -t for running tests to check your network interface
- [ ] -S for getting statistics
- [ ] arp- manipulate the system ARP cache
- [ ] dhclient- DHCP client
- [ ] netstat - display network connections
- [ ] -n for IP addresses instead of hostnames
- [ ] -t to show only TCP connections
- [ ] -p to show the PID of the program
- [ ] -l to show only listening sockets
- [ ] lsof - list open files
- [ ] -i for sockets
- [ ] traceroute - print the route packets trace to network host
- [ ] mtr - network diagnostic tool (traceroute + ping)
[ ] Files
- [ ] /proc/net/dev - network interfaces list
- [ ] /pro/net/arp - ARP table
- [ ] /etc/sysconfig/network-scripts/* - network configuration files in RHEL based OSs
- [ ] /etc/network/interfaces - network configuration files in Ubuntu
[ ] Types of interfaces
- [ ] Regular
- [ ] Dummy
- [ ] Virtual IP
- [ ] Veth
[ ] Bonding
- [ ] Modes
- [ ] How to activate
[ ] Network Namespaces
- [ ] ip netns
- [ ] ip netns add for adding namespaces
- [ ] ip netns list for listing namespaces
- [ ] ip netns del for removing namespaces
- [ ] ip netns exec for executing commands inside a network namespace
[ ] Network Kernel Parameters
- [ ] sysctl net.*
- [ ] /proc/sys/net/*
[ ] Packet Sniffers (one is enough)
- [ ] tcpdump
- [ ] wireshark
- [ ] dhcpdump
- [ ] httpry
[ ] Test
- [ ] How to list the interfaces in your system?
- [ ] How to display the routing table?
- [ ] How to change the MTU of an interface?

Debugging & Troubleshooting

[ ] CPU and Memory
- [ ] top - processes memory and cpu consumption
- [ ] free - amount of free and used memory
- [ ] -g for the amount of memory in gigabytes
- [ ] vmstat - virtual memory statistics
- [ ] htop - interactive process viewer
- [ ] atop - system and process monitor
- [ ] /proc/meminfo
[ ] Network Commands
- [ ] netstat - network connections
- [ ] traceroute - network connections
- [ ] IPTraf - IP LAN monitoring
- [ ] iftop - network bandwidth monitoring
[ ] Disk and Filesystem
- [ ] iotop - I/O monitor
- [ ] iostat - I/O statistics for devices and partitions

Processes

[ ] States
- [ ] Running
- [ ] Waiting
- [ ] Stopped
- [ ] Zombie
[ ] Files
- [ ] /proc/[PID]
[ ] Running in the background
- [ ] For example: my_program &

Files - Part 2

[ ] Commands
- [ ] find - search for files
- [ ] sort - sort, merge, or sequence check text files
- [ ] sort - sort, merge, or sequence check text files

Storage & Filesystem

[ ] inode
[ ] Links
- [ ] soft link
- [ ] hard link
[ ] Commands
- [ ] file - determine file type
- [ ] stat - file or file system status
[ ] LVM
- [ ] pv
- [ ] vg
- [ ] lv
[ ] Test
- [ ] Can you create soft links between different file systems? what about hard links?
- [ ] What information inode stores?

Hardware

[ ] Commands
- [ ] lshw - list hardware
- [ ] lspci - list all PCI devices
- [ ] dmidecode - DMI table decoder

For latest updated checklist visit DevOpsBit

Getting started with Pipenv

Arie Bregman — Thu, 14 Nov 2019 15:20:36 +0000

Whas is Pipenv?

A package management tool which makes combined use of

pip – Python package manager
virtualenv – used for creating isolated Python environments so you can easily use different packages in different projects
Pipefile – records the package versions used in a given project so you can easily install them on any other system you want. Also considered as the replacement of Python requirements files

So basically with one short pipenv command you can install a package in a virtual environment and record it in pipfile and pipefile.lock files. Think of pipenv as next gen package management tool that should save you time and also provide you with new shiny utilities.

Why using Pipenv?

One tool to rule them all – as stated a second ago, no need to use pip and virtualenv separately. You will benefit from all the tools I just mentioned, by using one simple command.
Provides you with many great utilities like creating a graph of your dependency tree, checking for security vulnerabilities and even assists you with creating issues on Github when bumping into a problem (more on that later on).

Overall, pipenv feels like the proper way to manage packages and dependencies in your Python projects.

Why not using Pipenv?

It probably seems unusual to have a “why not” section in a tutorial post but I prefer you’ll know the full truth on pipenv rather than getting the feeling it's ultimate package management tool.

Pipenv is not a free-from-bugs tool (like any other software) but in my short experience with it, I have bumped into numerous problems. Sometimes it’s the price you have to pay when switching to newer technology but some will say it’s too buggy to use at this point. Personally, I think you should still give it a try but don't expect a smooth experience.
It also has controversial behaviors that you might not like. This issue describes how pipenv ignores user chosen shell and spawns sh instead (I can confirm it as I’m experiencing the same).

Nonetheless, I'm still using it and before you choose whether to use it or not, it’s best to give it a try so let's see how to use it.

Install pipenv

This step depends on which operating system you are using. If you are using Fedora like me (ore CentOS/RHEL) run the following

sudo dnf install pipenv -y

Hello Pipenv

Let’s start using pipenv by installing a requirement. I'm going to install flask, you can install whatever you are using for your projects.

pipenv install flask

This short command will result in:

Creating a new virtual environment automatically
Creating a new Pipfile & Pipfile.lock files
Installing flask

Pretty nice, no?

Pipfile

Once the package is installed, you’ll notice pipenv has created a file called ‘Pipfile’ (and ‘Pipfile.lock'). This file basically records all the packages you installed in your virtual environment so when you want to send someone the project, or install it in another environment you can easily do so by using the Pipfile file.

Let’s see how a Pipfile file looks like

[source]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]

flask = “*”

[dev-packages]

[requires]

python_version = “3.7”

First part, source, is pretty standard and fixed for probably most of the projects. It specifies the source for the different packages. In our case, PyPi. The largest (and official) source for Python packages.

Next one is packages section which specifies the packages you installed in the virtual environment. An asterisk means no specific version was given. If you installed a specific version of flask, you’d see there a number/version instead of an asterisk.

The last section is ‘requires’ where you can specify which Python version your application should be using. In our case we can see Python 3.7 was used while installing flask.

Pipfile.lock

At first glance, Pipfile.lock might look similar in its content to the Pipfile file. It also specifies the packages mentioned in Pipfile and their versions but one major difference is that it includes the download hashes.

It includes download hashes since the purpose of this file is to provide deterministic builds, meaning it includes all dependencies and download hashes so you can easily reproduce builds with the exact packages that were used originally when you developed the project.

Note that you can and probably should manage both Pipfile and Pipfile.lock with version control. Similarly to how you are managing requirements files.

Work within the virtualenv

So far you created a new virtaulenv with pipenv and installed requirements into it but you didn’t actually activate it. So any command you’ll execute (which is not pipenv) will run outside the virtualenv pipenv created for you.

In order to switch to the virtualenv created by pipenv run the following command

pipenv shell

This will basically spawns a shell inside the virtualenv created by pipenv.

If don’t want to spawn a shell but simply execute one or more specific commands, you can use

pipenv run <command>

and it will run the command inside the virtualenv pipenv created.

Removing virtual environment

If you want to remove your virtualenv you can do it with

pipenv --rm command

Don’t worry about Pipfile files. It will not remove them which means you can instantly recreate the environment you used before removing the virtual environment.

Install local packages

You might be working on a project, locally on your computer and at some point, you would like to install it in your virtualenv and see how it works. It’s possible by using the following command

pipenv install -e .
It’s equivalent to pip install . which used for the same purpose of local project installations.

Note it will update your Pipfile content with

<project_name> = {editable = true, path = "."}

Update Pipfile.lock

It’s possible you’ll make changes in your environment not using pipenv. After all, it takes time to get used to new tools. In case it happens, you can still update your Pipfile.lock accordingly with pipenv lock

This will update your pipfile.lock to reflect the packages used in your virtualenv. If the file doesn’t exist, it will generate it from scratch, allowing you, or anyone using your project, to run deterministic builds.

Pipenv issues

As I wrote at the beginning of the post, there is a high probability you’ll bump into some issue with pipenv while trying it out. Fortunately, pipenv developers made it quite easy to collect information on your environment with the --supprt flag. Some of the information it collects is:

Python version
PEP 508 information (dependency specification)
System environment variables
The content of Pipfile and Pipfile.lock files
You can then easily copy the output you get from running pipenv --support and paste into a GitHub issue which describes your problem.

I like this approach as it saves time for both users and project maintainers since a user doesn’t need to guess which information would be useful for the maintainers and the maintainers are used to process the same format with every issue.

10 Ansible Interview Questions

Arie Bregman — Wed, 13 Nov 2019 20:07:38 +0000

Core Components

Describe each of the following components in Ansible, including the relationship between them:

Task
Module
Play
Playbook
Role

Answer

Task – a call to a specific Ansible module
Module – the actual unit of code executed by Ansible on your own host or a remote host. Modules are indexed by category (database, file, network, …) and also referred to as task plugins.

Play – One or more tasks executed on a given host(s)

Playbook – One or more plays. Each play can be executed on the same or different hosts

Role – Ansible roles allows you to group resources based on certain functionality/service such that they can be easily reused. In a role, you have directories for variables, defaults, files, templates, handlers, tasks, and metadata. You can then use the role by simply specifying it in your playbook.

Simple Task

Write a task to create the directory ‘/tmp/new_directory’

Answer

A very basic question, but indicates how you work with Ansible. Many will answer this question by using the shell or command modules. It doesn’t necessarily bad, but the best practice is always to use an explicit Ansible module (in our case, the ‘file’ module).

Why? Mainly due to readability. Some actions execute differently on different operating systems, but the module use is always the same and any Ansible user will know what you meant when reading the task (especially if it’s a long shell command).

Note: it doesn’t necessarily mean that modules are faster than the command(s) you specified with ‘shell’ or ‘command’.

The task of creating the directory

- name: Create a new directory
  file:
      path: "/tmp/new_directory"
      state: directory

What is the result?

What would be the result of the following play?

---
- name: Print information about my host
  hosts: localhost
  gather_facts: 'no'
  tasks:
      - name: Print hostname
        debug:
            msg: "It's me, {{ ansible_hostname }}"

Answer

When given a written code, always inspect it thoroughly. If your answer is “this will fail” then you are right. We are using a fact (ansible_hostname), which is a gathered piece of information from the host we are running on. But in this case, we disabled facts gathering (gather_facts: no) so the variable would be undefined which will result in failure.

The purpose of this question is to check if you know what is a fact but also whether you are paying attention to the small details.

Similar/follow-up questions can be:

How to list all facts available?
How to set a fact of your own?

Write a playbook

Write a playbook to install ‘zlib’ and ‘vim’ on all hosts if the file ‘/tmp/mario’ exists on the system

Answer

---
- hosts: all
  vars:
      mario_file: /tmp/mario
      package_list:
          - 'zlib'
          - 'vim'
  tasks:
      - name: Check for mario file
        stat:
            path: "{{ mario_file }}"
        register: mario_f

      - name: Install zlib and vim if mario file exists
        become: "yes"
        package:
            name: "{{ item }}"
            state: present
        with_items: "{{ package_list }}"
        when: mario_f.stat.exists

To answer this question you have to be familiar with register, conditionals, and loops*.

The first task uses the ‘stat’ module to check if the file exists on each system then captures the output in a variable called ‘mario_f’ using the ‘register’ term. You can then use the registered variable in any other task. In our case, we capture the stats of ‘/tmp/mario’ file and in the next task, we install the package list if the file exists.

As you can see, for installing the packages we used the “with_items” loop which allow us to iterate over a list and perform the module/task per item in the list. Loops, as in any other language, is a fundamental part of Ansible and you should be aware of the different types of loops supported with Ansible.

Another worth to mention line is ‘become: yes’ which allows us to run the task as root, but can be used with any user we will specify (e.g. become: ‘toad’). The task installing package list will fail unless this line is included since package installation can be done only with sudo permissions on the machine.

Bonus: Some Ansible modules can receive a list as an argument. In our case, the loop process could have been removed completely by simply providing the package_list variable straight to the ‘package’ module. Also, we could have removed the “stat” module completely by using the Ansible ‘with_fileglob’ loop, which iterates a list of files found by a regex. To sum this up:

---
- hosts: all
  vars:
      package_list:
        - 'zlib'
        - 'vim'
  tasks:
      - name: Install zlib and vim if mario file exists
        become: "yes"
        package:
            name:"{{ package_list }}"
            state: present
        with_fileglob:
            - 'tmp/mario'

Using Templates

Write a playbook to deploy the file ‘/tmp/system_info’ on all hosts except for controllers group, with the following content

I'm [HOSTNAME] and my operating system is [OS]

replace [HOSTNAME] and [OS] with the actual data for the specific host you are running on

Answer

The playbook to deploy the system_info file

---
- name: Deploy /tmp/system_info file
  hosts: all:!controllers
  tasks:
      - name: Deploy /tmp/system_info
        template:
            src: system_info.j2
            dest: /tmp/system_info

The content of the system_info.j2 template

I'm {{ ansible_hostname }} and my operating system is {{ ansible_distribution }}

Using a template will make your playbooks and roles much more dynamic and easily adjusted to different scenarios. Ansible uses a powerful templating engine called ‘Jinja2‘ to construct dynamic templates of files. Many popular projects and companies are using it (Flask, Mozilla, …) and we strongly recommend you take the time and learn using it as it will serve you well in the future.

When writing jinja templates for Ansible it is considered best practice to add the variable ‘ansible_managed’ at the top of the template. This variable expands to a string letting whoever reads the output file that this file was generated by Ansible and managed by it.
Next, we use ansible_hostname which is the unqualified name of the host and ansible_distribution which is the OS distro.

Be aware that this question could be implemented in other ways. For example, instead of using ansible_hostname, someone could use inventory_hostname. They are not the same, but they both would fit fine in this case.

Testing Ansible based projects

How do you test your Ansible based projects?

Answer

When I ask this question in some interviews, I get many different answers. Let’s go over some of them.

Manual run: “I simply run it and check if the system is in the desired state” – Personally I don’t like this answer when provided solely. I could agree this is the easiest one (or laziest) but it potentially quite dangerous. Even if you tested your new written role in a development environment, it doesn’t mean you’ll get the same result in a production environment.
Check mode – yes, check mode is a good way to test your Ansible code as it will report to you what it would have done if it would actually run without check mode. So you can easily see if the Ansible run behavior is meeting your expectations. But the follow-up question here is “and what about scripts?”. Usually, the answer I get here is “what about them?” 🙂 that’s fine if you didn’t have to use scripts in your roles and playbooks, but if you did, you would know that check mode doesn’t run scripts and commands. To run them, you would have to disable check mode for specific tasks with “check_mode: no”.
Asserts: I like asserts as a method of testing as it also resembles how you test in other languages such as Python and more importantly, it makes sure that your system reached the desired state, not as a draft like in check mode, but as an actual verification that the task changed certain resource to the desired state. To summarize, simply be confident when explaining your choice (also, it’s not realistic to expect someone to use them all, so don’t go this way 🙂 )

Writing another playbook

Write a playbook to install PostgreSQL on all servers in database group (assume Redhat) and update postgresql.conf with a configuration from the template postgresql.conf.j2 (assume it’s there, don’t write one).

In addition, provide users with a way to run only the configuration update task (without installing the packages).

Answer

There are two things you should not miss here: handlers and tags. Your playbook should look similar to the following:

---

- name: Installing PostgreSQL
  hosts: databases
  vars:
      pg_packages:
        - postgresql
        - postgresql-client
      pg_service: postgresql
      pg_admin_user: postgres
      pg_admin_group: postgres
      pg_version: 1981

  tasks:
      - name: Install PostgreSQL packages
        become: yes
        yum:
            name: "{{ item }}"
            state: latest
        loop: "{{ pg_packages }}"
        notify:
            - start_postgresql

      - name: Update postgres.conf file
        template:
            src: postgres.conf.j2
            dest: /etc/postgresql/{{ pg_version }}/postgresql.conf
            owner: {{ pg_admin_user }}
            group: {{ pg_admin_group }}
            mode: 0644
        become: yes
        notify:
            - restart postgresql
        tags:
            - postgres_config

  handlers:
      - name: start_postgresql
        service:
            name: "{{ pg_service }}"
            state: started

      - name: restart_postgresql
        service:
            name: "{{ pg_service }}"
            state: restarted

As you can see I have put everything in the same file, but a better solution would be to create a role and put each section into its own directory (vars, handlers, tasks, …). We’ll have detailed question and answer on roles later on.

The first thing to note here is handlers. Handlers allow us to trigger action (usually a task) upon a change. As you can see, the syntax is quite simple, using the keyword ‘notify’ we can provide a list of actions to execute. This makes a clear separation between what are the main tasks, required for installing and configuring PostgreSQL and what are the small “sub” actions required for the tasks to be complete.

The second thing to note here is ‘tags’. This answers the second part of the question on how to allow users to run only the configuration update part. Imagine you have 100 tasks and you want only run a small portion of them, let’s say four tasks which responsible for updating your application. Without tags, you would have to run everything in your playbook, but tags allow you to run only those you marked with a specific tag.

Variable precedence

Let’s say you used the same variable name (whoami) in several places with different values:

role defaults -> whoami: mario
extra vars (variables you pass to Ansible CLI with -e) -> whoami: toad
host facts -> whoami: luigi
inventory variables (doesn’t matter which type) -> whoami: browser
Which one will be used eventually? Why?

Answer

The right answer is ‘toad’.

Variable precedence is about how variables override each other when they set in different locations. If you didn’t experience it so far I’m sure at some point you will, which makes it a useful topic to be aware of.

In the context of our question, the order will be extra vars (always override any other variable) -> host facts -> inventory variables -> role defaults (the weakest).

A full list can be found at the link above. Also, note there is a significant difference between Ansible 1.x and 2.x.

Ansible Best Practices

Which Ansible best practices are you familiar with? name at least three

Answer

When using several parameters it’s better to use the YAML dictionary format. I personally find it much more readable.

# BAD

- name: Update postgres.conf file
  template: src=postgres.conf.j2
            dest=/etc/postgresql/{{ pg_version }}/postgresql.conf
            owner={{ pg_admin_user }} group={{ pg_admin_group }}
            mode=0644
# GOOD

- name: Update postgres.conf file
  template:
      src: postgres.conf.j2
      dest: /etc/postgresql/{{ pg_version }}/postgresql.conf
      owner: {{ pg_admin_user }}
      group: {{ pg_admin_group }}
      mode: 0644

“Always Name Tasks”. It’s good to get used to name every task you add. Even the simple among them, like using the ‘debug’ module. The name of the task gives some indication as to what it does and why it was added. It can be a workaround a known bug or it can be a long and juicy command so the user reads/using your playbook will appreciate if you describe shortly what it does.

# BAD

- template:
    src: postgres.conf.j2
    dest: /etc/postgresql/{{ pg_version }}/postgresql.conf

# GOOD

- name: Update postgres.conf file
  template:
      src: postgres.conf.j2
      dest: /etc/postgresql/{{ pg_version }}/postgresql.conf

Any change to Ansible code should pass ansible-lint. This is another non-official best practice which is basically a best-practices checker. This is why I consider it as one of the most important best practices to implement as it makes it easier to make sure other best practices are being followed, especially in a shared repository where you have several contributors.

As already stated, not every mentioned best practice is an official one (= in Ansible docs) and that’s totally fine as long as you can explain why it’s a best practice (or more accurately a good practice).

Ad-Hoc

Write an Ansible Ad-Hoc command to create the file ‘/tmp/info” on all hosts with the content: “The inventory file is in [inventory_file_path] and the inventory groups are [inventory_groups]”

Note: you should also list the hosts which included in the inventory groups

Answer

Knowing the different ways to execute Ansible can save you time in the future. One of them is the Ad-Hoc way which is a very quick way to run anything on a remote host.

In our case, our ad-hoc command will look like this

ansible all -m copy -a 'content="The inventory file is in {{ inventory_dir }} and the inventory groups are {{ groups }}" dest=/tmp/info'

-m for specifying the module name. We used ‘copy’ but you could also use other modules for achieving the same result.

-a are the arguments we are passing to the module like the content of the file and where to create it (‘dest’)

I suggest running a couple of ad-hoc commands in order to be familiar with it and feel comfortable enough to run them on demand.

DEV Community: Arie Bregman

How to prepare for DevOps & SRE interviews?

Skills you should have

Linux

Coding

Architecture and Design

Tools

Scenarios || Challenges || Tasks

Start your own DevOps project

Sample interview questions

Networking

Know your resume

Know the company

Books

Consider starting in non-DevOps position

What to expect from a DevOps interview?

Don't forget to be an interviewer as well

One Last Thing

5 Open Source Projects That Will Make You Smile

Volkswagen CI

Bash Insulter

Thanos JS

Bullshit.js

Pizza-Dough

More open source projects that will make us smile :)

Collection of Linux Resources

Learn Linux Sites for Beginners

Linux Videos

Blogs & News sites

Linux Books

Documentation

Linux Development Books

Forums and Communities

Online Courses (Not Free)

Random

Linux Checklist for Beginners

File System Hierarchy

Navigation

Files

Pattern Matching

Commands

Random

I/O redirection

Text Editor

Users

Network

Debugging & Troubleshooting

Processes

Archives

Files - Part 2

Storage & Filesystem

Hardware

Getting started with Pipenv

Whas is Pipenv?

Why using Pipenv?

Why not using Pipenv?

Install pipenv

Hello Pipenv

Pipfile

Pipfile.lock

Work within the virtualenv

Removing virtual environment

Install local packages

Update Pipfile.lock

Pipenv issues

More content

10 Ansible Interview Questions

Core Components

Answer

Simple Task

Answer

What is the result?

Answer

Write a playbook

Answer

Using Templates

Answer

Testing Ansible based projects

Answer

Writing another playbook