DevRel Intern @ Humalect
Priyansh Khodiyar, Jan 2023 — Present
Hello, नमस्ते, hola, bonjour, nín hǎo, asalaam alaikum, konnichiwa, chào, good to see you here.
This is a mini-article about my internship experience at Humalect!
It all started with me applying to a DevRel intern LinkedIn post by Humalect’s CEO which was WhatsApp shared with me by my friend.
Gawd how lucky that turned out for me.
I DM’ed (the CEO) regarding the post. I almost forgot about it and moved on with life and one fine day, I got a text back which was followed by a short meeting with the CEO, and he said “I read your SigNoz DevRel internship experience article (I posted that on LinkedIn too, and this on too :)) and you seemed fit for us”.
The moral of the story — Writing can open up opportunities for you that you never dreamt of.
He also said, “Take all your time and when you decide, text me”. I couldn’t just believe what had just happened, it was more like they wanted me to join and not me applying at 100 places just to get a callback from somewhere.
I immediately called 2 of my best people to tell them, still on my nerves and shivering hands. [But no khushi ke aanshu ;)]
I accepted it and then was added to the Humalect team Slack. It was my first experience in a closed slack room with founding engineers and other people. My previous experience as an intern at a well-funded Indian startup was more or less limited to being in contact with the guy who managed me, via a Community Slack channel and not their team’s one.
Anyway, I felt involved, being treated as one of them. While not the best onboarding but far far better than what I had experience with.
The first task I got was to document the Humalect Platform, there was no documentation before. I was cool with it. The platform then was a little less mature than it is today but I got to work. Lord Manav was my go-to person, he taught me about the platform and took a small DevOps session too (which to this day I remember).
Fast-forward, we used Asana to track the assigned, completed and reviewed documentation pages and nearly it got over in a month’s time. It was not hectic and I was glad that it’s over. Now finally I can get hands-on with the tech side of things. At least that was what I thought.
Next, I got to work on the platform testing side of things, mostly e2e.
I was told to come up with a testing tool comparing the pros and cons of already available open-source tools, did my research and thought Selenium could be a better option.
Started learning selenium and writing tests to automate clicks, fillings forms and stuff.
Here are the Selenium scripts I wrote — https://github.com/zriyansh/selenium-learn
Few lines from the repo:
import unittest
import time
import random
import re
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import Select
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
def humalect_login():
driver = webdriver.Chrome()
driver.get("https://console.dev.humalect.com/")
time.sleep(2)
try:
elem = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.NAME, "email"))
)
elem.send_keys("priyansh@humalect.com")
elem2 = driver.find_element(By.NAME, "password")
elem2.send_keys("xxx")Turns out, I made a mistake, Selenium was slow, outdated and too manual to test react-built sites. Wasted a week over it and switched over to Cypress, it was modern, built for the exact same thing we needed it for, and fast and had built-in automation tools.
So, I wrote someJavascript scripts for things like logging in to the platform, creating a cluster, creating a datasource, etc
Here’s my Cypress work — https://github.com/zriyansh/cypress-learn
Few lines from Cypress as well:
/// <reference types="cypress" />
describe('login humalect', () => {
beforeEach(() => {
cy.viewport(1280, 720)
cy.visit('https://console.dev.humalect.com/public/user/login')
cy.contains('Forgot password ?').should('exist')
cy.contains('Sign Up').should('exist')
cy.contains('Login with google').should('exist')
cy.get('form > :nth-child(1) > .w-full').type('priyansh@humalect.com')
cy.get(':nth-child(2) > .w-full').type('xxxxxxxxx')
cy.get('button').contains('Login').click()
})
it('created a redis v2 db', () =>{
cy.wait(2000)
cy.contains('Datasources').click()
cy.contains('Create New Datasource').click()And with this, it was the end of automated testing using Cypress.
Now whenever we shipped a new feature, I tested it manually (sometimes) and to be honest we did not require testing using Cypress at that time, it was overkill for a project that ships fast with breaking changes.
So, I repeatedly asked them to give me something on the tech side and was asked to make a proof of concept in RabbitMQ. For those of you who don’t know what breed of rabbit this is, pun intended, it is a message queuing service.
I submitted the mini project and worked over the weekend and I guess the rabbit jumped too high and took that opportunity from me to get involved in the tech side.
Oh and here’s the Github link for it — https://github.com/zriyansh/rabbitMQ-learn-js
Nothing fancy to look at, pretty basic stuff.
Moving forward, It was almost the end of March and I was now tasked with creating demo applications,
basically, tech stacks like:
- Rust — https://github.com/Humalect/simple-rust-app
- Ruby on Rails — https://github.com/Humalect/simple-rails-app
- Django — https://github.com/Humalect/simple-django-app
- Discord Bot — https://github.com/Humalect/discord-bot-sample
- Spring Boot- https://github.com/Humalect/spring-boot-starter
- Go — https://github.com/Humalect/Golang-starter
- NodeJS + Postgres -https://github.com/Humalect/nodejs-application-with-postgres-db
and Dockerfiles of them that work with the Humalect platform.
A Dockerfile looks something like this:
Example Dockerfile
FROM python:latest
RUN pip3 install discord.py
RUN pip3 install python-dotenv
WORKDIR /app
COPY *.py ./
CMD [ “python”, “./main.py”]And after this was done, I made a monorepo to be deployed on the Platform containing React, Angular and NodeJs.
Meanwhile, documentation work continued in parallel, and I started wiring tutorials on Kubernetes and how to use various Kubectl commands to play with your pods and stuff like that.
It was such a learning experience for me, I was forced to learn (I mean it was new territory for me, not something made to do without interest) about things that I wanted to learn about and so although now I started to feel a little burnt out, although I was learning a great deal of advanced things.
A few of the things I covered in those blogs were:
How to Create & Use Kubernetes Secrets
kubectl config set-context Tutorial
How to start Kubernetes Pod using kubectl
Docker Commands Cheat Sheet
How to Install & Deploy Prometheus Operator
Kubernetes namespace tutorial
kubeadm Tutorial
Terraform cheatsheet
Docker Cleanup
kubectl Get Nodes
Kubernetes Liveness Probes
Kubernetes StatefulSet
Kubernetes Exec
kubectl Proxy
Kubernetes Dashboard
kubectl rollout restart
Kubernetes NGINX Ingress
AWS Fargate
Delete EC2 Instance
Terraform Apply
Helm vs Kustomize
Keep docker container running
kubectl get events
kubectl delete deployment
AWS EKSLinks to everything is here — https://humalect.com/blog/
Here’s a quick glimpse of the sheet we used to maintain. I don’t even know if this should be shared with the public. Looks harmless to me as the blogs are already out there.
Umm, I said a few and dumped here my entire work. Face-Palm!
It takes a real knowing of things before you set out to write about them, I probably read some 10 different articles on similar topics, not to mention documentation as the source of truth.
Never have I ever read so much about Kubernetes, it was more like I was being paid to learn things I liked.
Anyways, initially, I did not have a Minikube setup on my Mac (M1, 8, 256), due to extremely low storage, so installed it in my spare Windows laptop to play around with Kubernetes deployments.
Below is what all I did in the documentation section:-
Documentation of Platform:
1. Outlining step-by-step cloud integration procedures for both AWS and Azure.
2. Describing the supported data sources that seamlessly integrate with the platform, including MongoDB, Postgres, Redis, and MySQL, along with their respective versions.
3. Documenting the utilization of source code providers such as GitHub, GitLab, and Bitbucket.
4. Detailing the integration of monitoring tools like Datadog and Grafana Cloud. This allowed users to view Logs, Metrics, and Traces generated by their applications, facilitating monitoring of overall application health and debugging of potential issues.
5. Providing explicit instructions for creating Azure Kubernetes Service (AKS) clusters and Elastic Kubernetes Service (EKS) AWS clusters.
6. Defining pipeline flows for linking application repositories from connected source code providers. This involved tasks such as domain verification, port address configuration, subdomain setting, secret configuration, datasource creation (if necessary), and Dockerfile and YAML configuration (Deployment, Ingress, Service).
7. Documenting Role-Based Access Control (RBAC) guidelines to ensure a clear understanding of access levels for Organization administrators and users.
Culture at Humalect
- You won't feel an inferiority complex the moment you step in, proper onboarding with what we do and these are the people you will be working with.
- I don’t remember I got any deadline to finish a work, I do it any time I want and submit it, there is no inherent pressure, but you’ll feel like working.
- Games, ofc.
- CEO is one DM away to address any query you have, what else do you need?
- You can always say what you want to work and if there is something related, you get to work on it!
Yeah well, that’s pretty much it, been with solid 8 months with Humalect and looking to dive deep into Kubernetes to test the waters.
Send me a Hi on LinkedIn, that’d be super.
Till then stay awesome.
