The "End of Life" (EOL) page for Software provides information on the release dates, support periods, and security status of different Software versions. It lists the latest supported version, the end dates for older versions, and provides links to further resources. This page is useful for understanding the support lifecycle of Software releases and ensuring that you are using a version that receives updates and security patches.
Ref: https://endoflife.date/kotlin
Could not prepare statement [Table “XXXX” not found (this database is empty); SQL statement
Solution:
Add bellow configuration in test application.ymlspring:test:database:replace: none
---
Code:
testImplementation("org.springframework.boot:spring-boot-testcontainers")
testImplementation("org.testcontainers:junit-jupiter")
testImplementation("org.testcontainers:mariadb")
Test containers:
References:
test container examples here
Now a days, it's very difficult remember the vm passwords while connecting in the office network. So, Connect easily using sshpass.
For installation for mac/Linux:
Mac:
brew install hudochenkov/sshpass/sshpass
Linux:
yum install sshpass
Example of usage:
Ex:
sshpass -p test123 ssh root@192.168.1.1
Reafference:
https://stackoverflow.com/questions/32255660/how-to-install-sshpass-on-mac
The Single Root I/O Virtualization (SR-IOV) specification is a standard for a type of PCI device assignment that can share a single device with multiple pods.
SR-IOV enables you to segment a compliant network device, recognized on the host node as a physical function (PF), into multiple virtual functions (VFs), and make them available for direct IO to the POD.
Network Interface Cards (NICs) with SR-IOV capabilities are managed through physical functions (PFs) and virtual functions (VFs). A PF is used by the host and usually represents a single NIC port. VF configurations are applied through the PF. With SR-IOV CNI each VF can be treated as a separate network interface, assigned to a container, and configured with it's own MAC, VLAN, IP and more.
SR-IOV CNI plugin works with SR-IOV device plugin for VF allocation in Kubernetes. A metaplugin such as Multus gets the allocated VF's deviceID(PCI address) and is responsible for invoking the SR-IOV CNI plugin with that deviceID.
The end result will be similar to the in the picture except for the SRIOV-CNI and the DPDK userspace.
Reference:
https://github.com/ramanujadasu/sriov-cni
https://dramasamy.medium.com/high-performance-containerized-applications-in-kubernetes-f494cef3f8e8
Kubernetes is an open-source orchestration engine for automating deployments, scaling, managing, and providing the infrastructure to host containerized applications. At the infrastructure level, a Kubernetes cluster is comprised of a set of physical or virtual machines, each acting in a specific role.
Master components are responsible for managing the Kubernetes cluster. They manage the life cycle of pods, the base unit of a deployment within a Kubernetes cluster. Master servers run the following components:
kube-apiserver – the main component, exposing APIs for the other master components.
etcd – distributed key/value store which Kubernetes uses for persistent storage of all cluster information.
kube-scheduler – uses information in the pod spec to decide on which node to run a pod.
kube-controller-manager – responsible for node management (detecting if a node fails), pod replication, and endpoint creation.
cloud-controller-manager – daemon acting like an abstraction layer between the APIs and the different cloud providers’ tools (storage volumes, load balancers etc.)
Node components are worker machines in Kubernetes and are managed by the Master. A node may be a virtual machine (VM) or physical machine, and Kubernetes runs equally well on both types of systems. Each node contains the necessary components to run pods:
kubelet – watches the API server for pods on that node and makes sure they are running
cAdvisor – collects metrics about pods running on that particular node
kube-proxy – watches the API server for pods/services changes in order to maintain the network up to date
container runtime – responsible for managing container images and running containers on that node
Reference:
https://www.suse.com/c/rancher_blog/understanding-the-kubernetes-node/#:~:text=kubelet%20%E2%80%93%20watches%20the%20API%20server,the%20network%20up%20to%20date
MacBook process to add new VPN entry:
cd /opt/cisco/anyconnect/profile
sudo cp clientprofile_old.xml clientprofile_new.xml
sudo vi clientprofile_new.xml
Update hostname and hostaddress
Ex:
<ServerList>
<HostEntry>
<HostName>NEW</HostName>
<HostAddress>127.0.0.1</HostAddress>
</HostEntry>
</ServerList>
Few mac tools for easy connect Virtual Machines:
https://mobaxterm.mobatek.net/
https://apps.apple.com/us/app/zen-term-lite-ssh-client/id1422475219?mt=12
Reference:
https://documentation.meraki.com/MX/AnyConnect_on_the_MX_Appliance/Client_deployment
DevOps is about cultural change and providing a way for development teams and operations teams to work together collaboratively. GitOps gives you tools and a framework to take DevOps practices, like collaboration, CI/CD, and version control, and apply them to infrastructure automation and application deployment.
GitOps Free Training(LinuxFoundation):
https://trainingportal.linuxfoundation.org/learn/course/introduction-to-gitops-lfs169/course-introduction/course-information
Reference:
https://www.redhat.com/en/topics/devops/what-is-gitops#:~:text=DevOps%20is%20about%20cultural%20change,infrastructure%20automation%20and%20application%20deployment.
What is istio:
Reference: https://istio.io/latest/about/service-mesh/
==
Install docker:
https://docs.docker.com/desktop/mac/install/
==
Create cluster using kind:
brew install kind
kind version
Demo file: https://github.com/ramanujadasu/istio-kind/blob/LearningMain/demo.yml
kind create cluster --config demo.yml --name cluster2
kind get clusters
Reference: https://kind.sigs.k8s.io/docs/user/quick-start/#installation
==
Checking cluster is installed successfully:
docker ps
==
Download Istio:
curl -L https://istio.io/downloadIstio | sh -
cd istio-1.13.2
export PATH=$PWD/bin:$PATH
==
Install Istio:
istioctl install --set profile=demo -y
kubectl label namespace default istio-injection=enabled
==
Modify the http2 and https ports:
Changes for http and https port info istio-ingressgateway:
kubectl edit service istio-ingressgateway -n istio-system
Update below nodeports:
- name: http2
nodePort: 30080
port: 80
protocol: TCP
targetPort: 8080
- name: https
nodePort: 30443
port: 443
protocol: TCP
targetPort: 8443
==
Deploy the sample application:
kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml
kubectl get services
kubectl get pods
==
Verify everything is working correctly:
kubectl exec "$(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}')" -c ratings -- curl -sS productpage:9080/productpage | grep -o "<title>.*</title>"
==
Open the application to outside traffic:
Associate this application with the Istio gateway:
kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml
==
Ensure that there are no issues with the configuration:
istioctl analyze
==
Set Gateway:
export GATEWAY_URL=localhost:80
==
Open browser and test bellow URL:
http://localhost:80/productpage
kubectl apply -f samples/addons
kubectl rollout status deployment/kiali -n istio-system
Kiali:
Kiali is a management console for Istio service mesh. Kiali can be quickly installed as an Istio add-on, or trusted as a part of your production environment. See below for more about what Kiali offers
istioctl dashboard kiali
http://localhost:20001/
Reference:
https://istio.io/latest/docs/tasks/observability/kiali/
https://kiali.io/
Open the terminal and run bellow command:
for i in $(seq 1 100); do curl -s -o /dev/null "http://$GATEWAY_URL/productpage"; done
Now you can see the graphs:
Prometheus:
Prometheus is an open source monitoring system and time series database. You can use Prometheus with Istio to record metrics that track the health of Istio and of applications within the service mesh. You can visualize metrics using tools like Grafana and Kiali.
istioctl dashboard prometheus
http://localhost:9090/
Reference:
https://istio.io/latest/docs/tasks/observability/metrics/using-istio-dashboard/
https://istio.io/latest/docs/tasks/observability/metrics/querying-metrics/
https://istio.io/latest/docs/ops/integrations/prometheus/
https://prometheus.io/
==
Jaeger:
It is open source, end-to-end distributed tracing and monitor and troubleshoot transactions in complex distributed systems
istioctl dash jaeger
http://localhost:16686/jaeger/search
https://www.jaegertracing.io/
==
Grafana:
istioctl d grafana
http://localhost:3000/?orgId=1
https://grafana.com/
==
Envoy:
istioctl d envoy productpage-v1-7ff6d55f74-pj8dm
https://istio.io/latest/docs/ops/diagnostic-tools/proxy-cmd/
http://localhost:15000/
==
Controlz:
istioctl d controlz istiod-699b647f8b-dgqw6
http://localhost:9876/metricz/
==
Zipkin:
Zipkin is a distributed tracing system. It helps gather timing data needed to troubleshoot latency problems in service architectures. Features include both the collection and lookup of this data.
istioctl dashboard zipkin
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.13/samples/addons/extras/zipkin.yaml
References:
https://istio.io/latest/docs/ops/integrations/zipkin/#installation
https://istio.io/latest/docs/tasks/observability/distributed-tracing/zipkin/
https://istio.io/latest/docs/tasks/observability/distributed-tracing/mesh-and-proxy-config/#customizing-trace-sampling
Skopeo is a tool for moving container images between different types of container storages. It allows you to copy container images between container registries like docker.io, quay.io, and your internal container registry or different types of storage on your local system.
Below are the steps to push or pull images from artifactory using skopeo instead of docker. Skopeo is just a cli and does not require any service/privilege. No change is needed on the docker or docker-desktop settings also.
Pre-Steps: Install skopeo
brew instal skopeo
Setup proxies if any issue with environment:
export http_proxy=<hostname>:<port>
export https_proxy=<hostname>:<port>
export no_proxy="io,com,org"
Login:
skopeo login --tls-verify=false -u USERNAME <repo-url>
Inspecting a repository
skopeo inspect --config docker://quay.io/podman/stable | json_pp
Copying images
Skopeo can copy container images between various storage mechanisms:
skopeo copy docker://<imagename:latest> docker://<imagename:latest>
ex: skopeo copy docker://registry.access.redhat.com/ubi8-init docker://reg.company.com/ubi-init
skopeo copy docker://registry.fedoraproject.org/fedora:latest containers-storage:fedora
If any restrictions repo: skopeo copy --override-arch=amd64 --override-os=linux --dest-tls-verify=false docker-daemon:<imagename:latest> docker://<imagename:latest>
Deleting images from a registry:
skopeo delete docker://localhost:5000/<imagename:latest>
Reference:
https://www.redhat.com/en/blog/skopeo-10-released#:~:text=Skopeo%20is%20a%20tool%20for,storage%20on%20your%20local%20system
We have different ways to connect couchdb in docker containers
>>> Using docker compose:
Step1:
create file docker-compose.yml::
version: '3'
services:
couchserver:
image: couchdb
restart: always
ports:
- "5984:5984"
environment:
- COUCHDB_USER=admin
- COUCHDB_PASSWORD=admin
volumes:
- ./dbdata:/opt/couchdb/data
Step2:
From the directory that contains your docker-compose.yml file, run:
docker-compose up -d
Step3:
Docker will pull your image and setup everything for you.
Soon as everything set, make sure your CouchDB container is up and running, but the following command:
docker ps
Step4:
Access CouchDB admin
In order to validate your working CouchDB install, head to http://localhost:5984/.
To access the CouchDB admin, head to http://localhost:5984/_utils/
=========================================
>>> Using Docker command:
Step1:
docker run -itd -p 25984:5984 -p 25986:5986 --name=couchdb2 \
-e NODENAME='couchdb-2.local.com' \
--mount 'source=volume-2,target=/opt/couchdb/data' \
couchdb:2.3.0
Step2:
curl -X GET http://localhost:25984
References:
https://medevel.com/tutorial-install-couchdb-with-docker/
https://medium.com/@singinjon/cluster-couchdb-2-and-docker-on-localhost-f0490649d960
A note on Python threads
If you start uWSGI without threads, the Python GIL will not be enabled, so threads generated by your application will never run. You may not like that choice, but remember that uWSGI is a language-independent server, so most of its choices are for maintaining it “agnostic”. But do not worry, there are basically no choices made by the uWSGI developers that cannot be changed with an option.
If you want to maintain Python threads support without starting multiple threads for your application, just add the --enable-threads option (or enable-threads = true in ini style).
[uwsgi] # ------------- # Settings: # key = value # Comments >> # # ------------- strict uid = root gid = root # socket = [addr:port] http-socket = 0.0.0.0:9034 wsgi-file = app.py callable = TEST_SERVICE # master = [master process (true of false)] master = true # processes = [number of processes] processes = 5 py-autoreload = 0 buffer-size = 32768 need-app = true attach-daemon = celery -A app.CELERY worker --loglevel=INFO --concurrency=1
Above properties detail information available below url:
Reference:
https://uwsgi-docs.readthedocs.io/en/latest/WSGIquickstart.html
List can be sorted using Java 8 Lambda Expressions, moving right past syntactic sugar and into real and powerful functional semantics. The implementation of all of these examples and code snippets can be found over on gitHub: https://github.com/ramanujadasu/tutorials/tree/master/core-java-modules/core-java-lambdas
List<Human> humans = Lists.newArrayList( new Human("Sarah", 10), new Human("Jack", 12) ); Basic Sort Without Lambdas: Collections.sort(humans, new Comparator<Human>() { @Override public int compare(Human h1, Human h2) { return h1.getName().compareTo(h2.getName()); } }); Basic Sort With Lambda Support: humans.sort( (Human h1, Human h2) -> h1.getName().compareTo(h2.getName())); Basic Sorting With No Type Definitions: humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName())); Sort Using Reference to Static Method: public static int compareByNameThenAge(Human lhs, Human rhs) { if (lhs.name.equals(rhs.name)) { return Integer.compare(lhs.age, rhs.age); } else { return lhs.name.compareTo(rhs.name); } } humans.sort(Human::compareByNameThenAge); Sort Extracted Comparators: Collections.sort( humans, Comparator.comparing(Human::getName)); Reverse Sort: Comparator<Human> comparator = (h1, h2) -> h1.getName().compareTo(h2.getName()); humans.sort(comparator.reversed()); Sort With Multiple Conditions: List<Human> humans = Lists.newArrayList( new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12) ); humans.sort((lhs, rhs) -> { if (lhs.getName().equals(rhs.getName())) { return Integer.compare(lhs.getAge(), rhs.getAge()); } else { return lhs.getName().compareTo(rhs.getName()); } }); Sort With Multiple Conditions -Composition: humans.sort( Comparator.comparing(Human::getName).thenComparing(Human::getAge) ); Sorting a List With Stream.sorted(): List<String> letters = Lists.newArrayList("B", "A", "C"); List<String> sortedLetters = letters.stream().sorted().collect(Collectors.toList()); == List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); Comparator<Human> nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName()); List<Human> sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList()); Or List<Human> sortedHumans = humans.stream() .sorted(Comparator.comparing(Human::getName)) .collect(Collectors.toList()); Sorting a List in Reverse With Stream.sorted(): List<String> letters = Lists.newArrayList("B", "A", "C"); List<String> reverseSortedLetters = letters.stream() .sorted(Comparator.reverseOrder()) .collect(Collectors.toList()); == List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); Comparator<Human> reverseNameComparator = (h1, h2) -> h2.getName().compareTo(h1.getName()); List<Human> reverseSortedHumans = humans.stream().sorted(reverseNameComparator) .collect(Collectors.toList()); Or List<Human> reverseSortedHumans = humans.stream() .sorted(Comparator.comparing(Human::getName, Comparator.reverseOrder())) .collect(Collectors.toList()); Null Values: List<Human> humans = Lists.newArrayList(null, new Human("Jack", 12)); humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName())); == List<Human> humans = Lists.newArrayList(null, new Human("Jack", 12), null); humans.sort((h1, h2) -> { if (h1 == null) { return h2 == null ? 0 : 1; } else if (h2 == null) { return -1; } return h1.getName().compareTo(h2.getName()); }); Or humans.sort(Comparator.nullsLast(Comparator.comparing(Human::getName))); Or humans.sort(Comparator.nullsFirst(Comparator.comparing(Human::getName)));
Marker interface has no method. Java has built-in marker interface like Serializable, Cloneable & Event Listener etc that are understand by JVM.
We can create our own marker interface, but it has nothing to do with JVM, we can add some checks with instanceOf.
Create the empty interface interface Marker{ } Write a class and implements the interface class A implements Marker { //do some task } Main class to check the marker interface instanceof class Main { public static void main(String[] args) { A ob = new A(){ if (ob instanceof A) { // do some task } } }
public class Test {
public static int test(int i) { try { if (i == 0) throw new Exception(); return 0; } catch (Exception e) { return 1; } finally { return 2; } } public static void main(String[] args) { System.out.println(test(0)); System.out.println(test(1)); } }
Output:22Cloud Computing is the delivery of on-demand computing resources (computer power, database storage, applications as well as other IT resources) over the internet. This is achieved by using a network of remote servers hosted on the internet rather than a local server/personal computer. A cloud service is any service made available to users on demand via the Internet from a cloud computing provider’s server as opposed to being provided from a company’s own on-premises servers. Infrastructure as a Service (IaaS), Platform as a Service (PaaS) and Software as a Service (SaaS) are the three categories of cloud services. Cloud service platforms provide the above-mentioned services.
Major cloud service platforms:
Amazon Web Services (AWS) – It’s a comprehensive, evolving cloud computing platform provided by Amazon. AWS delivers a mix of IaaS, PaaS, and SaaS.
Google Cloud – Google Cloud Platform is the suite of public cloud computing services by Google. It runs on the same infrastructure that Google uses internally for its end-user products, such as Google Search and YouTube. This includes a range of hosted services to compute, storage and application development that run on Google hardware. Google Cloud Platform services can be accessed by software developers, cloud administrators and other enterprise-IT professionals over the public internet or through a dedicated network connection.
IBM Cloud (formerly known as IBM Blemix and IBM Softlayer) – Cloud computing services from IBM which offers PaaS, SaaS, and IaaS. With IBM Cloud IaaS, organizations can deploy and access virtualized IT resources such as compute power, storage and networking over the internet. For compute, organizations can choose between bare-metal or virtual servers.
Alibaba Cloud – Subsidiary of Alibaba group which provide a suite of cloud computing services that covers elastic computing,
object storage, relational database, big data analysis, and artificial intelligence in fifteen geographical regions around the globe.
Oracle Cloud – Cloud service offering from Oracle Corporation. This provides servers, storage, network, applications and services through a global network of Oracle’s managed data centers. Here, services are provided over the internet, on demand.
Here, we can see the comparison between each of the above cloud platforms in general :Public Cloud:
Along with the above features, there is a need to consider these important factors while purchasing a cloud service:
Reference:
http://www.nodericks.com/aws-vs-azure-vs-google-vs-ibm-cloud-best/
https://www.tomsguide.com/features/aws-vs-azure-vs-google-cloud-vs-ibm-cloud-whats-the-best-cloud-environment
https://www.parkmycloud.com/blog/aws-vs-azure-vs-google-cloud-market-share/
Found few good tutorials and capture the profile building and data-structure concepts examples.
Profile creation tips and related sites:
https://github.com/ramanujadasu/golden-profile-tips/tree/main/profilecreationtips
Data structure concepts and example git repos:
https://github.com/ramanujadasu/golden-profile-tips/tree/main/datastructures
Visual view for DataStructures:
Java 9 Features:
Question: What is GAE and GCE in GCP?
Solution : Google App Engine (GAE) and Google Compute Engine (GCE) are both used for deploying applications and are equally popular with small and large businesses. Google App Engine is a Platform as a Service (PaaS) solution that makes deployment easier.The Google Compute Engine on the other hand is an Infrastructure as a Service (IaaS) tool.
Question: PaaS vs IaaS: What’s the Difference?
Solution : PaaS refers to cloud-based platform services that provide developers with a framework to build custom applications. Therefore, PaaS isn’t delivering software over the internet but provides a platform that’s accessible to different developers to create software that’s delivered over the internet.
IaaS cloud-based infrastructure resources are delivered to organizations with virtualization technology that helps them build and manage their servers, network, data storage and operating systems. IaaS customers can control their own data infrastructure without having to physically manage it on-site.
Reference: https://www.parallels.com/blogs/ras/app-engine-vs-compute-engine/
Question: What are the cloud databases in GCP?
Solution:
Relational
Bare Metal Solution for Oracle(Lift and shift Oracle workloads to Google Cloud),
Cloud SQL(Managed MySQL, PostgreSQL, and SQL Server),
Cloud Spanner(Cloud-native with unlimited scale, consistency, and 99.999% availability)
Key value
Cloud Bigtable(Cloud-native NoSQL wide-column store for large scale, low-latency workloads)
Document
Firestore(Cloud-native NoSQL to easily develop rich mobile, web, and IoT applications)
Firebase Realtime Database(Store and sync data in real time)
In-memory
Memorystore(Fully managed Redis and Memcached for sub-millisecond data access)
Additional NoSQL
MongoDB Atlas(Global cloud database service for modern applications)
Google Cloud Partner Services(Managed offerings from our open source partner network, including MongoDB, Datastax, Redis Labs, and Neo4j)
Reference: https://cloud.google.com/products/databases
