DEV Community: Aditya Yadav

Kubernetes Interview Questions

Aditya Yadav — Wed, 01 Feb 2023 06:24:40 +0000

1. What is Kubernetes and how does it work?

Kubernetes is an open-source platform for automating deployment, scaling, and management of containerized applications. It uses a declarative configuration to manage containers, as well as provide features such as self-healing, horizontal scaling, and service discovery.

2. Can you explain the architecture of a Kubernetes cluster?

A Kubernetes cluster consists of a set of worker nodes that run containerized applications, and a control plane that manages the state of the cluster and the applications. The control plane is composed of the API server, the controller manager, and the etcd database. The worker nodes communicate with the control plane to receive instructions and report the status of containers.

3. What are Pods, Replication Controllers, and Services in Kubernetes?

Pods are the smallest deployable units in Kubernetes and can contain one or more containers. Replication Controllers ensure that a specified number of pods are running at all times. Services provide stable network identities and load balancing for pods.

4. How does Kubernetes handle network communication between Pods?

Kubernetes uses a network overlay, such as Flannel or Calico, to provide communication between pods. Pods are assigned unique IP addresses, and services can be used to load balance network traffic to pods.

5. Can you explain the role of etcd in Kubernetes?

etcd is a distributed key-value store that is used to store the configuration data for a Kubernetes cluster. It serves as the source of truth for the cluster state and is used by the API server to persist the state of objects such as pods and services.

6. How does Kubernetes handle scaling of applications?

Kubernetes provides horizontal scaling by allowing users to increase or decrease the number of replicas of a given deployment. The Replication Controller or Deployment controller will then ensure that the desired number of replicas are running.

7. What is a ConfigMap in Kubernetes and how is it used?

A ConfigMap is a way to store configuration data as key-value pairs outside of a container image. It can be used to store configuration data for an application and can be mounted as a file or environment variables in a pod.

8. Can you describe the process of rolling updates in Kubernetes?

Rolling updates allow a user to update an application without any downtime by incrementally updating replicas in a deployment. The Replication Controller or Deployment controller updates one replica at a time, allowing the new version to be tested before the entire deployment is updated.

9. What are some common security concerns in Kubernetes and how are they addressed?

Some common security concerns in Kubernetes include network security, access control, and secrets management. Network security can be addressed using network policies and encryption of etcd data. Access control can be managed using Role-Based Access Control (RBAC) and secrets can be managed using secrets engines, such as Hashicorp Vault.

10. Can you explain the difference between a deployment and a stateful set in Kubernetes?

A Deployment is used to manage the scaling and updates of stateless applications, while a StatefulSet is used for stateful applications that require stable network identities and persistent storage. StatefulSets provide unique network identities for pods and maintain the order of pods during updates and rollbacks.

NodeJS Basics Interview Questions

Aditya Yadav — Sun, 29 Nov 2020 10:59:34 +0000

What is Node.js?

Node.js is an open-source, cross-platform, back-end, JavaScript runtime environment that executes JavaScript code outside a web browser.

What is it used for?

Node.js is primarily used for non-blocking, event-driven servers, due to its single-threaded nature. Node.js is used to build different type of applications such as web applications, real-time chat applications, REST API servers etc.

What is the advantage of using node.js?

It provides an easy way to build scalable network programs
Generally fast
Great concurrency
Asynchronous everything
Almost never blocks

Why Node.js is single threaded?

Node.js uses a single threaded model in order to support async processing. With async processing, an application can perform better and is more scalable under web loads.

How many types of API functions are there in Node.js?

There are two types of API functions in Node.js:

Asynchronous, non-blocking functions
Synchronous, blocking functions

Define Asynchronous and Non-blocking functions ?

Node.js based server never waits for an API to return data thus making it asynchronous.

Non-blocking functions are used in regards with I/O operations. They immediately respond with whatever data is available and keeps on running as per the requests. In case, any answer couldn’t be retrieved then the API returns immediately with an error.

What is Event-driven programming?

Event-driven programming is building our application based on and respond to events. When an event occurs, like click or keypress, we are running a callback function which is registered to the element for that event.

What is an Event-loop?

An event loop in Node.js handles all the asynchronous callbacks in an application. Node.js (or JavaScript) is a single-threaded, event-driven language. This means that we can attach listeners to events, and when a said event fires, the listener executes the callback we provided.

How does Event-loop work?

Whenever functions like setTimeout, http.get, and fs.readFile are called, Node.js executed the event loop and then proceeds with the further code without waiting for the output. Once the entire operation is finished, Node.js receives the output and then executes the callback function. This is why all the callback functions are placed in a queue in a loop. Once the response is received, they are executed one by one.

What is callback functions?

A callback is a function called at the completion of a given task, this prevent any blocking, and allows other code to be run in the meantime.

function A(callback){
  B(function (err,data){
    if(err){
      console.log("Error occored");
      callback(err)
    }
    data+=1;
    callback(data);
  });
}

Explain REPL in the context of Node.js.

REPL in Node.js stands for Read, Eval, Print, and Loop. It represents a computer environment such as a window console or Unix/Linux shell where any command can be entered and then the system can respond with an output. Node.js comes bundled with a REPL environment by default.

Explain the purpose of module.exports?

A module encapsulates related code into a single unit of code. This can be interpreted as moving all related functions into a file.

module.exports = {
A: function(){
return "NAMASTE";
},
B: function(){
return "Hello";
}};

What is callback hell?

Callback hell is heavily nested callback which makes the code unreadable and difficult to maintain.

Explain the concept of middleware in Node.js?

Middleware functions are functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle. The next middleware function is commonly denoted by a variable named next.

Middleware functions can perform the following tasks:

Execute any code.
Make changes to the request and the response objects.
End the request-response cycle.
Call the next middleware function in the stack.

What are the different types of HTTP requests?

HTTP defines a set of request methods used to perform desired actions. The request methods include:

GET: Used to retrieve the data

POST: Generally used to make a change in state or reactions on the server

HEAD: Similar to the GET method, but asks for the response without the response body

DELETE: Used to delete the predetermined resource

Basic ReactJS Interview Questions

Aditya Yadav — Sat, 21 Nov 2020 13:21:03 +0000

What is React?
React is a declarative, efficient, and flexible JavaScript library for building user interfaces. It lets you compose complex UIs from small and isolated pieces of code called “components”.

What are the feature of React?

JSX.
Use Virtual DOM.
Server-side rendering.
Uni-directional data-flow.
Components.

What is JSX?
JSX stands JavaScript XML. JSX with React to describe what the UI should look like. JSX may remind you of a template language, but it comes with the full power of JavaScript.

class App extends React.Component {
   render() {
      return (
         <div>
            Hello World!!!
         </div>
      );
   }
}

How can web browsers read JSX directly?
Broswer can read only JS file. For JSX it require Transpiler to transformed into JS file. React use Babel as Transpiler.

What is Virtual DOM?
The virtual DOM (VDOM) is a programming concept where an ideal, or “virtual”, representation of a UI is kept in memory and synced with the “real” DOM by a library such as ReactDOM. This process is called reconciliation.

What is Constructor in React?
Constructor is a special function in a JavaScript class. JavaScript invokes constructor() whenever an object is created via a class.

constructor(props) {
        super(props);

    }

What is State?
States are the heart of React components. The state is a data structure that starts with a default value when a Component mounts. It may be mutated across time, mostly as a result of user events.

A component with the state is known as stateful component. They are responsible for making component dynamic and interactive.

What is Props?
Props (short for properties) and it is immutable. Props are used to pass data from parent to child or by the component itself.

What is Components?
Components let you split the UI into independent, reusable pieces, and think about each piece in isolation.

Conceptually, components are like JavaScript functions. They accept arbitrary inputs (called “props”) and return React elements describing what should appear on the screen.

What are the differences between functional and class components?

Functional Components:-

It is called as stateless component. After introduction of Hooks, functional components are equivalent to class component. We call such components “function components” because they are literally JavaScript functions.

function Welcome(props) {
  return <h1>Hello, {props.name}</h1>;
}

Functional component take single props as a object argument with data and return a React element.

Class Components:-

It is called as stateful component because they can hold or manage local state.

class Welcome extends React.Component {
  render() {
    return <h1>Hello, {this.props.name}</h1>;
  }
}

What is Higher Order Component?
A higher-order component is a function that takes a component and returns a new component. A higher-order component (HOC) is an advanced technique in React for reusing component logic. HOCs are not part of the React API.

What are the different phases of React component’s lifecycle?
Three Phases of React components lifecycle:-

1. Initial Rendering Phase or Mounting:

This is the phase when the component is about to start its life journey and make its way to the DOM.

componentWillMount() :-

Executed just before rendering takes place both on the client as well as server-side.

render() :-

This is the only required method in the class component. This method returns the HTML elements which are going to be rendered inside the DOM.

componentDidMount() :–

Executed on the client side only after the first render.

2. Updating Phase:

Once the component gets added to the DOM, it can potentially update and re-render only when a prop or state change occurs. That happens only in this phase.

componentWillReceiveProps() :–

Invoked as soon as the props are received from the parent class and before another render is called.

shouldComponentUpdate() :–

Returns true or false value based on certain conditions. If you want your component to update, return true else return false. By default, it returns false.

componentWillUpdate() :–

Called just before rendering takes place in the DOM.

render() :-

This is the only required method in the class component. This method returns the HTML elements which are going to be rendered inside the DOM.

componentDidUpdate() :–

Called immediately after rendering takes place.

3. Unmounting Phase:

This is the final phase of a component’s life cycle in which the component is destroyed and removed from the DOM.

componentWillUnmount() :–

Called after the component is unmounted from the DOM. It is used to clear up the memory spaces.

What is Redux?
Redux is an open-source JavaScript library for managing application state. It is most commonly used with libraries such as React or Angular for building user interfaces.

List down the components of Redux.
Redux is composed of the following components:

Action – It’s an object that describes what happened.
Reducer – It is a place to determine how the state will change.
Store – State/ Object tree of the entire application is saved in the Store.
View – Simply displays the data provided by the Store.

What are the advantages of Redux?
Advantages of Redux are listed below:

Predictability of outcome :– Since there is always one source of truth, i.e. the store, there is no confusion about how to sync the current state with actions and other parts of the application.
Maintainability :– The code becomes easier to maintain with a predictable outcome and strict structure.
Server-side rendering :– You just need to pass the store created on the server, to the client side. This is very useful for initial render and provides a better user experience as it optimizes the application performance.
Developer tools :– From actions to state changes, developers can track everything going on in the application in real time.
Community and ecosystem :– Redux has a huge community behind it which makes it even more captivating to use. A large community of talented individuals contribute to the betterment of the library and develop various applications with it.
Ease of testing :– Redux’s code is mostly functions which are small, pure and isolated. This makes the code testable and independent.
Organization :– Redux is precise about how code should be organized, this makes the code more consistent and easier when a team works with it.

What is React Router?
React Router is a powerful routing library built on top of React, which helps in adding new screens and flows to the application. It maintains a standardized structure and behavior and is used for developing single page web applications. React Router has a simple API.

<Router>
    <Route path="/" component={Home} />
</Router>