Beyond Ingresses - Better Traffic Management in KubernetesMark McBride
Kubernetes makes deploying code easy, but conflating deploys and releases is risky. Using smarter proxies you can dramatically reduce the risk of a release, which in turn helps you ship code to customers faster.
Topology Service Injection using Dragonflow & KuryrEshed Gal-Or
Container-based Dynamic Service Chain using Distributed SDN Pipeline Injection (Openstack, Dragonflow, Kuryr).
With NFV becoming a reality, OpenStack Cloud deployments grow in number and size, giving birth to issues of scale, performance and service flexibility.
Linux Foundation CNCF CloudNativeDay
What's Hot in Containers & OpenStack - Duane De Capite
Duane De Capite details what's hot in container ecosystems including the emerging Linux Foundation Open Container Initiative (OCI) and Cloud Native Computing Foundation (CNCF) collaborative projects. Learn how OpenStack can leverage and enable container deployments including details on OpenStack projects Magnum, Kuryr and Kolla. Learn how networking projects including Calico and Contiv can integrate and scale container and OpenStack deployments. This session also summarized the buzz about Mantl.io, a new Platform as a Service (PaaS) project for containers and OpenStack.
http://events.linuxfoundation.org/events/cloudnativeday/program/schedule
Beyond Ingresses - Better Traffic Management in KubernetesMark McBride
Kubernetes makes deploying code easy, but conflating deploys and releases is risky. Using smarter proxies you can dramatically reduce the risk of a release, which in turn helps you ship code to customers faster.
Topology Service Injection using Dragonflow & KuryrEshed Gal-Or
Container-based Dynamic Service Chain using Distributed SDN Pipeline Injection (Openstack, Dragonflow, Kuryr).
With NFV becoming a reality, OpenStack Cloud deployments grow in number and size, giving birth to issues of scale, performance and service flexibility.
Linux Foundation CNCF CloudNativeDay
What's Hot in Containers & OpenStack - Duane De Capite
Duane De Capite details what's hot in container ecosystems including the emerging Linux Foundation Open Container Initiative (OCI) and Cloud Native Computing Foundation (CNCF) collaborative projects. Learn how OpenStack can leverage and enable container deployments including details on OpenStack projects Magnum, Kuryr and Kolla. Learn how networking projects including Calico and Contiv can integrate and scale container and OpenStack deployments. This session also summarized the buzz about Mantl.io, a new Platform as a Service (PaaS) project for containers and OpenStack.
http://events.linuxfoundation.org/events/cloudnativeday/program/schedule
A Kubernetes cluster contains a set of worker
machines known as nodes that run
containerized applications
ü Every cluster has at least one worker node.
Hence, if a node fails, your application will still
be accessible from the other nodes as in a
cluster, multiple nodes are grouped
Docker Kubernetes Istio
Understanding Docker and creating containers.
Container Orchestration based on Kubernetes
Blue Green Deployment, AB Testing, Canary Deployment, Traffic Rules based on Istio
Google has been running everything in containers for the past 15 years, but how do we orchestrate and manage all those containers? We've built and released the open source Kubernetes (http://kubernetes.io), which is based on years of running containers internally at Google. Join us for an introduction to containers and Kubernetes, followed by a hands-on workshop building and deploying your own Kubernetes cluster with multiple front end, database and caching instances.
Docker containers help solve the issue of process-level reproducibility by packaging up your apps and execution environments into a number of containers. But once you have a lot of containers running, you'll need to coordinate them across a cluster of machines while keeping them healthy and making sure they can find each other. This can quickly turn into an unmanageable mess! Wouldn't it be helpful if you could declare what wanted, and then have the cluster assign the resources to get it done and to recover from failures and scale on demand? Kubernetes is here to help!
Key takeaways
- Gentle introduction into containers: why and how
- Learn how Google manages applications using containers
- Intro to Kubernetes: managing applications and services
- Build and deploy your own multi-tier application using Kubernetes
Kubernetes is designed to be an extensible system. But what is the vision for Kubernetes Extensibility? Do you know the difference between webhooks and cloud providers, or between CRI, CSI, and CNI? In this talk we will explore what extension points exist, how they have evolved, and how to use them to make the system do new and interesting things. We’ll give our vision for how they will probably evolve in the future, and talk about the sorts of things we expect the broader Kubernetes ecosystem to build with them.
ZCloud Consensus on Hardware for Distributed SystemsGokhan Boranalp
3rd Workshop on Dependability,
May 8, Monday 2017, İYTE,
https://goo.gl/fSVnZy
http://dcs.iyte.edu.tr/ws/ppt/10/presentation.pdf
In distributed applications where the number of members in the cluster increases, the
separation of the consensus related operations at the hardware level is essential for the
following reasons:
1. At the operating system level, messages broadcast on the protocol stack cause latency.
2. It is necessary to increase the number of completed transactions in the communication of
distributed system components and on the network unit (throughput).
3. For devices with limited storage and CPU computing facilities that use embedded operating
systems such as IOT devices, it is also necessary to reduce the processing burden due to
"consensus" operations.
4. A common consensus communication model is needed for different applications that need
to work together in (BFT) distributed systems.
Using Deep Learning Toolkits with Kubernetes clustersJoy Qiao
Slides for the talk at the O'Reilly AI Conference San Francisco 2017 - https://conferences.oreilly.com/artificial-intelligence/ai-ca/public/schedule/detail/59613
Driving Business and Technical Agility in the Enterprise!
Container World 2017 is the only independent conference offering an exploration of the entire container ecosystem. Over 3 days, you’ll hear from the innovative enterprises, tech giants and startups who are transforming enterprise IT and driving business innovation on such topics as:
Containers and legacy infrastructure
Operations/DevOps
Orchestration & Workloads
Security
Storage/Persistent storage
Standardization and Certification
Emerging technology like serverless, unikernel and beyond
View the brochure for more information: https://goo.gl/OpnoEr
Kubernetes Interview Questions And Answers | Kubernetes Tutorial | Kubernetes...Edureka!
( Kubernetes Certification Training: https://www.edureka.co/kubernetes-certification )
This Edureka tutorial on "Kubernetes Interview Questions" will help you crack interviews on various Kubernetes related roles in the industry. The different types of questions included in this session are:
1. Basic Kubernetes Interview Questions
2. Kubernetes Architecture-Based Interview Questions
3. Scenario-Based Interview Questions
4. Multiple Choice Questions
DevOps Tutorial Blog Series: https://goo.gl/P0zAfF
On Friday 5 June 2015 I gave a talk called Cluster Management with Kubernetes to a general audience at the University of Edinburgh. The talk includes an example of a music store system with a Kibana front end UI and an Elasticsearch based back end which helps to make concrete concepts like pods, replication controllers and services.
Kubernetes seems to be the biggest buzz word currently in the DevOps world. The Google designed container orchestrator based in their 10+ years of experience running production applications using containers seems to have positioned as the market leader.
Open source, available in both Google Cloud and Azure container platforms or as a custom installation, it is ready to receive production loads.
During this talk we will discover how does Kubernetes works, its architecture, what components compose a Kubernetes cluster. We will also learn what objects can a developer use to deploy its applications on a Kubernetes cluster. We will see a live demo where we will deploy an application and then introduce changes to it without any downtime.
Introduction to containers, k8s, Microservices & Cloud NativeTerry Wang
Slides built to upskill and enable internal team and/or partners on foundational infra skills to work in a containerized world.
Topics covered
- Container / Containerization
- Docker
- k8s / container orchestration
- Microservices
- Service Mesh / Serverless
- Cloud Native (apps & infra)
- Relationship between Kubernetes and Runtime Fabric
Audiences: MuleSoft internal technical team, partners, Runtime Fabric users.
Taking the Next Hot Mobile Game Live with Docker and IBM SoftLayerDaniel Krook
Presentation at the IBM InterConnect Conference in Las Vegas, Nevada on February 24, 2016.
Mobile games are the fastest-growing sector of the $70 billion video game industry, far outpacing traditional consoles. But companies that aspire to create the next hot title have to account for more than just the app downloaded to a user device. They must prepare for huge spikes in game play with scalable backends to handle massive data and transactions behind socially linked user profiles and global leaderboards. This talk looks at how IBM successfully partnered with Firemonkeys, a major studio that had hit their vertical scaling limit, to design and deploy a new Docker-based architecture on SoftLayer. This scale-out architecture is able to handle an order of magnitude more customers for their next major release.
Kube Overview and Kube Conformance Certification OpenSource101 RaleighBrad Topol
This is my Introduction to Kubernetes and Overview of the Kubernetes Conformance Certification Program talk presented at OpenSource101 Raleigh on Feb 17, 2018
Cloud Foundry Diego: The New Cloud Runtime - CloudOpen Europe Talk 2015David Soul
A talk on the extensibility of the new Cloud Foundry platform runtime presented at the CloudOpen Europe conference in Dublin, Oct 2015.
Outlines how the new, flexible cloud primitives in the upcoming Cloud Foundry Diego platform runtime were adapted to support additional workloads and environments, including Docker images and the Lattice project for local development. The talk included a live demo of deploying Docker images to a Lattice runtime running on Amazon EC2. One hour talk given at CloudOpen Europe in 5th October 2015.
Links:
CloudOpen EU Conference - http://events.linuxfoundation.org/events/cloudopen-europe/ and http://sched.co/3xVy
OSS Projects - http://cloudfoundry.org and http://lattice.cf
Talk Photos - http://david-soul.com/?p=555
Abstract: An overview of Diego, the new Cloud Foundry runtime design for orchestrating heterogeneous containerized workloads across multiple cloud infrastructures. Learn how Diego manages tasks and long-running processes using auction-based scheduling and monitoring for Docker and Garden containers.
Credit to the Cloud Foundry dev team and more, including Onsi Fakhouri, Eric Malm, Matt Stine, Amit Gupta, Bridget Kromhout, Renee French and Cornela Davis.
Kubernetes for FaaS (Function as a Service) - Serverless evolution, some basic constructs, kubenetes features, comparisons - from Serverless conference 2017 Bangalore.
Soft Introduction to Google's framework for taming containers in the cloud. For devs and architects that they just enter the world of cloud, microservices and containers
A Kubernetes cluster contains a set of worker
machines known as nodes that run
containerized applications
ü Every cluster has at least one worker node.
Hence, if a node fails, your application will still
be accessible from the other nodes as in a
cluster, multiple nodes are grouped
Docker Kubernetes Istio
Understanding Docker and creating containers.
Container Orchestration based on Kubernetes
Blue Green Deployment, AB Testing, Canary Deployment, Traffic Rules based on Istio
Google has been running everything in containers for the past 15 years, but how do we orchestrate and manage all those containers? We've built and released the open source Kubernetes (http://kubernetes.io), which is based on years of running containers internally at Google. Join us for an introduction to containers and Kubernetes, followed by a hands-on workshop building and deploying your own Kubernetes cluster with multiple front end, database and caching instances.
Docker containers help solve the issue of process-level reproducibility by packaging up your apps and execution environments into a number of containers. But once you have a lot of containers running, you'll need to coordinate them across a cluster of machines while keeping them healthy and making sure they can find each other. This can quickly turn into an unmanageable mess! Wouldn't it be helpful if you could declare what wanted, and then have the cluster assign the resources to get it done and to recover from failures and scale on demand? Kubernetes is here to help!
Key takeaways
- Gentle introduction into containers: why and how
- Learn how Google manages applications using containers
- Intro to Kubernetes: managing applications and services
- Build and deploy your own multi-tier application using Kubernetes
Kubernetes is designed to be an extensible system. But what is the vision for Kubernetes Extensibility? Do you know the difference between webhooks and cloud providers, or between CRI, CSI, and CNI? In this talk we will explore what extension points exist, how they have evolved, and how to use them to make the system do new and interesting things. We’ll give our vision for how they will probably evolve in the future, and talk about the sorts of things we expect the broader Kubernetes ecosystem to build with them.
ZCloud Consensus on Hardware for Distributed SystemsGokhan Boranalp
3rd Workshop on Dependability,
May 8, Monday 2017, İYTE,
https://goo.gl/fSVnZy
http://dcs.iyte.edu.tr/ws/ppt/10/presentation.pdf
In distributed applications where the number of members in the cluster increases, the
separation of the consensus related operations at the hardware level is essential for the
following reasons:
1. At the operating system level, messages broadcast on the protocol stack cause latency.
2. It is necessary to increase the number of completed transactions in the communication of
distributed system components and on the network unit (throughput).
3. For devices with limited storage and CPU computing facilities that use embedded operating
systems such as IOT devices, it is also necessary to reduce the processing burden due to
"consensus" operations.
4. A common consensus communication model is needed for different applications that need
to work together in (BFT) distributed systems.
Using Deep Learning Toolkits with Kubernetes clustersJoy Qiao
Slides for the talk at the O'Reilly AI Conference San Francisco 2017 - https://conferences.oreilly.com/artificial-intelligence/ai-ca/public/schedule/detail/59613
Driving Business and Technical Agility in the Enterprise!
Container World 2017 is the only independent conference offering an exploration of the entire container ecosystem. Over 3 days, you’ll hear from the innovative enterprises, tech giants and startups who are transforming enterprise IT and driving business innovation on such topics as:
Containers and legacy infrastructure
Operations/DevOps
Orchestration & Workloads
Security
Storage/Persistent storage
Standardization and Certification
Emerging technology like serverless, unikernel and beyond
View the brochure for more information: https://goo.gl/OpnoEr
Kubernetes Interview Questions And Answers | Kubernetes Tutorial | Kubernetes...Edureka!
( Kubernetes Certification Training: https://www.edureka.co/kubernetes-certification )
This Edureka tutorial on "Kubernetes Interview Questions" will help you crack interviews on various Kubernetes related roles in the industry. The different types of questions included in this session are:
1. Basic Kubernetes Interview Questions
2. Kubernetes Architecture-Based Interview Questions
3. Scenario-Based Interview Questions
4. Multiple Choice Questions
DevOps Tutorial Blog Series: https://goo.gl/P0zAfF
On Friday 5 June 2015 I gave a talk called Cluster Management with Kubernetes to a general audience at the University of Edinburgh. The talk includes an example of a music store system with a Kibana front end UI and an Elasticsearch based back end which helps to make concrete concepts like pods, replication controllers and services.
Kubernetes seems to be the biggest buzz word currently in the DevOps world. The Google designed container orchestrator based in their 10+ years of experience running production applications using containers seems to have positioned as the market leader.
Open source, available in both Google Cloud and Azure container platforms or as a custom installation, it is ready to receive production loads.
During this talk we will discover how does Kubernetes works, its architecture, what components compose a Kubernetes cluster. We will also learn what objects can a developer use to deploy its applications on a Kubernetes cluster. We will see a live demo where we will deploy an application and then introduce changes to it without any downtime.
Introduction to containers, k8s, Microservices & Cloud NativeTerry Wang
Slides built to upskill and enable internal team and/or partners on foundational infra skills to work in a containerized world.
Topics covered
- Container / Containerization
- Docker
- k8s / container orchestration
- Microservices
- Service Mesh / Serverless
- Cloud Native (apps & infra)
- Relationship between Kubernetes and Runtime Fabric
Audiences: MuleSoft internal technical team, partners, Runtime Fabric users.
Taking the Next Hot Mobile Game Live with Docker and IBM SoftLayerDaniel Krook
Presentation at the IBM InterConnect Conference in Las Vegas, Nevada on February 24, 2016.
Mobile games are the fastest-growing sector of the $70 billion video game industry, far outpacing traditional consoles. But companies that aspire to create the next hot title have to account for more than just the app downloaded to a user device. They must prepare for huge spikes in game play with scalable backends to handle massive data and transactions behind socially linked user profiles and global leaderboards. This talk looks at how IBM successfully partnered with Firemonkeys, a major studio that had hit their vertical scaling limit, to design and deploy a new Docker-based architecture on SoftLayer. This scale-out architecture is able to handle an order of magnitude more customers for their next major release.
Kube Overview and Kube Conformance Certification OpenSource101 RaleighBrad Topol
This is my Introduction to Kubernetes and Overview of the Kubernetes Conformance Certification Program talk presented at OpenSource101 Raleigh on Feb 17, 2018
Cloud Foundry Diego: The New Cloud Runtime - CloudOpen Europe Talk 2015David Soul
A talk on the extensibility of the new Cloud Foundry platform runtime presented at the CloudOpen Europe conference in Dublin, Oct 2015.
Outlines how the new, flexible cloud primitives in the upcoming Cloud Foundry Diego platform runtime were adapted to support additional workloads and environments, including Docker images and the Lattice project for local development. The talk included a live demo of deploying Docker images to a Lattice runtime running on Amazon EC2. One hour talk given at CloudOpen Europe in 5th October 2015.
Links:
CloudOpen EU Conference - http://events.linuxfoundation.org/events/cloudopen-europe/ and http://sched.co/3xVy
OSS Projects - http://cloudfoundry.org and http://lattice.cf
Talk Photos - http://david-soul.com/?p=555
Abstract: An overview of Diego, the new Cloud Foundry runtime design for orchestrating heterogeneous containerized workloads across multiple cloud infrastructures. Learn how Diego manages tasks and long-running processes using auction-based scheduling and monitoring for Docker and Garden containers.
Credit to the Cloud Foundry dev team and more, including Onsi Fakhouri, Eric Malm, Matt Stine, Amit Gupta, Bridget Kromhout, Renee French and Cornela Davis.
Kubernetes for FaaS (Function as a Service) - Serverless evolution, some basic constructs, kubenetes features, comparisons - from Serverless conference 2017 Bangalore.
Soft Introduction to Google's framework for taming containers in the cloud. For devs and architects that they just enter the world of cloud, microservices and containers
Container orchestration engine for automating deployment, scaling, and management of containerized applications.
What are Microservices?
What is container?
What is Containerization?
What is Docker?
Kubernetes: A Top Notch Automation SolutionFibonalabs
Kubernetes is a portable, extensible open-source platform that facilitates automated deployment, scaling, and management of Linux containerized applications. It was developed by Google, written using the GO language. It is a PaaS(Platform as a Service) when used on the cloud, whereas it is also flexible as an IaaS(Infrastructure as a Service) and SaaS(Software as a Service) by enabling portability, simplified scaling, and provision of robust software models.
In the era of Microservices, Cloud Computing and Serverless architecture, it’s useful to understand Kubernetes and learn how to use it. However, the official Kubernetes documentation can be hard to decipher, especially for newcomers. In this book, I will present a simplified view of Kubernetes and give examples of how to use it for deploying microservices using different cloud providers, including Azure, Amazon, Google Cloud and even IBM.
Federated Kubernetes: As a Platform for Distributed Scientific ComputingBob Killen
A high level overview of Kubernetes Federation and the challenges encountered when building out a Platform for multi-institutional Research and Distributed Scientific Computing.
Kubernetes (commonly referred to as "K8s") is an open-source system for automating deployment, scaling and management of containerized applications It aims to provide a "platform for automating deployment, scaling, and operations of application containers across clusters of hosts". We will see Kubernetes architecture, use cases, basics and live demo
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
GridMate - End to end testing is a critical piece to ensure quality and avoid...ThomasParaiso2
End to end testing is a critical piece to ensure quality and avoid regressions. In this session, we share our journey building an E2E testing pipeline for GridMate components (LWC and Aura) using Cypress, JSForce, FakerJS…
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
2. Kubernetes a clustered container orchestration Software
an open-source system for automating deployment, scaling, and
management of containerized applications.
It groups containers that make up an application into logical units for easy management and discovery. Kubernetes builds upon 15
years of experience of running production workloads at Google, combined with best-of-breed ideas and practices from the
community.
Now maintained by CNCF a non profit organization sponsored by the largest companies in tech like
google,amazon,microsoft , redhat …...
5. Desired State And the Declarative Model
In k8s we use the declarative model instead of the procedural model .
In the the declarative model we define the desired state of our object .
unlike the procedural model where we define steps and execute them.
In k8s every configuration is made using the declarative model where
we describe the target status of our object
So in the procedural model we would run a container like this : Docker run nginx
6. Desired State And the Declarative Model
In the declarative model it would be:
apiVersion: v1
kind: Pod
metadata:
name: nginx
spec:
containers:
– name: nginx
image: nginx
7. Basics - POD
Pod
Kubernetes targets the management of elastic applications that consist of multiple
microservices communicating with each other. Often those microservices are
tightly coupled forming a group of containers that would typically, in a
non-containerized setup run together on one server. This group, the smallest unit
that can be scheduled to be deployed through K8s is called a pod.
8. Basics - POD
This group of containers would share storage, Linux namespaces, cgroups, IP
addresses. These are co-located, hence share resources and are always
scheduled together.
Pods are not intended to live long. They are created, destroyed and re-created on
demand, based on the state of the server and the service itself.
9. Basics - DEPLOYMENT
A Deployment controller provides declarative updates for Pods and
ReplicaSets.
You describe a desired state in a Deployment object, and the
Deployment controller changes the actual state to the desired
state at a controlled rate. You can define Deployments to create
new ReplicaSets, or to remove existing Deployments and adopt all
their resources with new Deployments.
10. Basics - SERVICE
As pods have a short lifetime, there is no guarantee about the IP address they are served on. This could make the communication of
microservices hard.
Imagine a typical Frontend communication with Backend services.
Hence K8s has introduced the concept of a service, which is an abstraction on top of a number of pods, typically requiring to run a
proxy on top, for other services to communicate with it via a Virtual IP address.
This is where you can configure load balancing for your numerous pods and expose them via a service.
11. Basics - SERVICE
We can create different types of services :
➜ Clusterip Create a clusterIP service.
➜ externalname Create an ExternalName service.
➜ Loadbalancer Create a LoadBalancer service.
➜ nodeport Create a NodePort service.
14. Networking
The Kubernetes networking model is based on a flat address space. All pods in a cluster can directly see each other. Each
pod has its own IP address. There is no need to configure any NAT. In addition, containers in the same pod share their pod's
IP address and can communicate with each other through localhost. This model is pretty opinionated, but once set up, it
simplifies life considerably both for developers and administrators. It makes it particularly easy to migrate traditional
network
applications to Kubernetes. A pod represents a traditional node and each container represents a traditional process.
15. Networking
Kubernetes use the CNI drivers model . where container networking is a driver in kubernetes and can be replaced
The major cni drivers are
Docker - Default network for single node ( minikube) uses macvlan network
Weave - an overlay network driver
Flannel - full subnet to every host backed by etcd to manage networks uses in kernel VXlAN
Calico - layer 3 kernel level implementation uses bgp for node communication does not need to use nat
Canal - a mix of both flannel and calico combines the best of bot
16. Networking
Kubernetes networking
Inter-pod communication (pod to pod)
Pods in Kubernetes are allocated a network-visible IP address (not private to the node). Pods can communicate directly without the aid
of network address translation, tunnels, proxies, or any other obfuscating layer. Well-known port
numbers can be used for a configuration-free communication scheme. The pod's internal IP address is the same as its external IP
address that other pods see (within the cluster network; not exposed to the outside world). That means that standard
naming and discovery mechanisms such as DNS work out of the box.
Pod to service communication
Pods can talk to each other directly using their IP addresses and well-known ports, but that requires the pods to know each other's IP
addresses. In a Kubernetes cluster, pods can be destroyed and created constantly. The service provides a layer of indirection that is
very useful because the service is stable even if the set of actual pods that respond to requests is ever-changing. In addition, you get
automatic, highly available load balancing because the Kube-proxy on each node takes care of redirecting traffic to the correct pod:
18. Deployments
A Deployment controller provides declarative updates for Pods and ReplicaSets.
You describe a desired state in a Deployment object, and the Deployment controller changes the actual state to the
desired state at a controlled rate. You can define Deployments to create new ReplicaSets, or to remove existing
Deployments and adopt all their resources with new Deployments.
19. Deployments
The best practices for multi tier apps on k8s are standard we
will discuss a few points .
● differentiate between the backend and the frontend with
some logical api
● all logs should be printed to stdout of containers
● all apps should be stateless except for the storage points
which should have an external storage
20. Deployments
● all apps should be defined in k8s as deployments with :
○ replicas more than one
○ health check should be defined
○ resource requests and limit should be set to be able to
account for storage /cpu /memory starvation
○ versioning metadata should be defined .
21. Deployments
● when updating databases facing app:
○ have any update to be backward compatible or
○ every database should be wrapped with an api dal
○ in any case avoid multiple writers/readers to the same
DB at most try to keep one reader/writer
● plan for failure and at any time fails pods to test for system
stability (chaos monkey)
22. METADATA
Metadata in k8s has a very big role .
As k8s provides the ability to do service discovery . we need a way to describe our services and
application
And based on that discovery we do the internal data flow of our app .
To help us in achieving manageable application k8s adds a meta data to all our apps .
Based on that metadata we define and control the flow of data in our apps .
In each pod/deployment/service/replicaset we can add a label inside our metadata section .
That allows us to tag our resources with a simple key: value pair .
We can use that key value pair to then connect services to pod/deployments and play with the flow of our
apps .
24. Deployments methods
Canary Release is the technique that we use to “softly” deploy
a new version of an application into Production. It consists of
letting only a part of the audience get access to the new
version of the app, while the rest still access the “old” version
one. This is very useful when we want to be sure about
stability in case of any changes which may be breaking, and
have big side effects.
25. Deployments methods
The point is: canary release has never been easy to be put into practice.
Depending on the environment we have, it can take so long to be put in
place that we often prefer to leave this away.
However, with Docker containers and Kubernetes orchestration it is quite
friendly to do that.
26. Deployments methods
Blue-green deployment is a technique that reduces downtime and risk by
running two identical production environments called Blue and Green.
At any time, only one of the environments is accessable , with the live
environment serving all production traffic. For this example, Blue is
currently live and Green is idle.
27. Deployments methods
As you prepare a new version of your software, deployment and the final
stage of testing takes place in the environment that is not live: in this
example, Green. Once you have deployed and fully tested the software in
Green, you switch the router so all incoming requests now go to Green
instead of Blue. Green is now live, and Blue is idle.
This technique can eliminate downtime due to application deployment. In
addition, blue-green deployment reduces risk: if something unexpected
happens with your new version on Green, you can immediately roll back to
the last version by switching back to Blue.
28. Deployments methods
A/B testing (sometimes called split testing) is comparing
two versions of a web page to see which one performs
better.
You compare two web pages by showing the two variants
(let's call them A and B) to similar visitors at the same time.
The one that gives a better conversion rate, wins!
29. Deployments methods
Rolling update
To update a service without an outage, kubectl supports what is called ‘rolling update’, which updates one pod at a time,
rather than taking down the entire service at the same time.
Rolling Update Deployment
The Deployment updates Pods in a rolling update fashion when .spec.strategy.type==RollingUpdate. You can specify
maxUnavailable and maxSurge to control the rolling update process.
30. Deployments Hands on
Login labs.play-with-k8s.com
clone : https://github.com/mikiha81/k8smeetup.git
On labs.play-with-k8s press the + button to add a node . and run the commands
1. kubeadm init --apiserver-advertise-address $(hostname -i)
2. kubectl apply -n kube-system -f
"https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 |tr -d
'n')"
Then press the + again and copy from the first node the kubeadm join command
and run it in the second node
31. Deployments Hands on
Deploy the yamls from nginx folder in the git project this is
the base line deploy .
Verify you can access it using curl run
Kubectl get svc and check the node port in the 3XXXX range
And from node 2 issue the command :
while true; do curl http://localhost:30938/version.html ; sleep
1 ; done
32. Deployments Hands on
Canray release :
In the canary-release folder print the yaml and look at the changes ….
apply the deployment yaml .
Run kubectl get pod verify the pod is up and ready .
Then go back to the 2nd node and look at the result of the curl .
Whats going on ?
Next delete the deployment for canary kubectl delete -f deployment.yaml
33. Deployments Hands on
Blue green deployment :
In the blue green deployment
First apply the service-2.0.yaml
Then apply the deployment.yaml
Wait for the container to become ready .
And apply the service.yaml …
Look the result of the curl .
What’s going on ?
Now delete the deployment .. and apply the service.yaml from the nginx folder .
34. Deployments Hands on
A/B TESTING :
How do you do it ?
Play with the deployment yaml and the service.yaml from the nginx folder and use
the v2.5 tag
Remember to reset deployment and service back to nginx default before moving
on
35. Deployments Hands on
Rolling update :
Because our default update policy is rolling update is
To do a rolling update ..
Run the command
kubectl set image deployment nginx nginx=mikiha/nginx:2.6
Run a kubectl get pod and look the pods replacing ope by one .
And go to the second node … look the curl log
36. K8s deployments limitations
deployments in kubernetes while being advanced still has some limitations
● no dependencies between different deployments
● no versioning of deployments
● somewhat limited variables declaration
● no flow control in descriptive
● no hooks when deploying and upgrading so /deploy/upgrade is linear
● no central repository for application deployment declaration
37. Deployment solution
The solution for our issues HELM
helm is maintained by the CNCF which also maintains k8s
helm uses go syntax for declarative language in deploying application to k8s
advantages of helm
● central repository
● full descriptive language with flow control
● full hooks for before and after deploying
● allows specifying of dependencies
● full versioning support
● full templating support
38. Helm - intro
Helm is a clients server solution made out of two apps .
Tiller thats the server that talks k8s and deploys the configuration to K8s.
Helm . the Client that does some of the heavy lifting and compiles the charts and
turns them into releases that deploys to tiller .
both tiller and helm are go binaries . (small and static)
as helm supports remote repositories helm know how to download charts from
remote repositories (like yum apt brew apk) . but helm does not provide a way to
upload a chart to a remote server .
39. Helm - intro continued
Helm deploys charts - those are the templates to create k8s deployments
services and most of the resources that k8s supports .
once a chart is “compiled “ and deploys to a k8s server it turn to a release .
to look for releases in a repo you can use helm search
to list charts and releases use helm ls
for instance :
helm ls
NAME REVISION UPDATED STATUS CHART NAMESPACE
miki-wordpress 1 Sun Apr 15 00:32:55 2018 DEPLOYED wordpress-1.0.0 default
viable-aardvark 1 Tue Apr 10 15:29:04 2018 DEPLOYED wordpress-1.0.0 default
40. Helm - intro continued
as you can see in this case we have two different releases for wordpress with the
same chart , this is done when using the helm install.
the first chart was installed with --name = RELEASE NAME flag , the second one
was just helm install wordpress .
also we can see the status, namespace and the revision , we can do rollback to
previous versions
helm ls
NAME REVISION UPDATED STATUS CHART
NAMESPACE
miki-wordpress 1 Sun Apr 15 00:32:55 2018 DEPLOYED wordpress-1.0.0 default
viable-aardvark 1 Tue Apr 10 15:29:04 2018 DEPLOYED wordpress-1.0.0 default
41. Helm - intro
to create a chart we use the create command in helm once we do this we create a boilerplate folder with
the name of the chart we use so . .
helm create miki-small-app
this creates the files we need for our owne chart
Charts.yaml - contains the name,description,version of the chart
values.yaml - default values that we can modify and access from each template
templates folder - a template folder contains our resources templates, we will
we will modify them for our deployments as the
template files - this can al be yaml files we declare and container resources
they must not start with _
_helpers.tpl - template file for go definitions such as function or descriptive logic code
miki-small-app/
├── charts
├── Chart.yaml
├── templates
│ ├── deployment.yaml
│ ├── _helpers.tpl
│ ├── ingress.yaml
│ ├── NOTES.txt
│ └── service.yaml
└── values.yaml
42. Helm - intro
chart folder can container a number of other chart to install other charts manually
- an optional file is requirements.yaml in the that can link to dependent charts
and their versions like
also alias field can point
to a release name
and is optional
tags and condition is also
optional
condition can link to
a value that we can reference from our parent chart
miki-small-app/
├── charts
├── Chart.yaml
├── templates
│ ├── deployment.yaml
│ ├── _helpers.tpl
│ ├── ingress.yaml
│ ├── NOTES.txt
│ └── service.yaml
└── values.yaml
dependencies:
- name: subchart
repository: http://localhost:10191
version: 0.1.0
alias: new-subchart-1
tag:
- subchart1
condition: subchart1.enabled
43. Helm - intro
looking at out default deployment :
we see some default yaml we know and love from k8s
but there are some {{ }} code . this is a generated code
from the go engine of helm , we can use this to create
descriptive code we can access from other files .
so in the name field we have the {{template “chart.fullname”}}
this actually goes to our templates file and looks for the name
of the variables we define .
same as .Values.replicacount goes to our variable.yaml file .
and the .Release.Name goes to our Charts.yaml and takes our
release name .
apiVersion: apps/v1beta2
kind: Deployment
metadata:
name: {{ template "miki-small-app.fullname" . }}
labels:
app: {{ template "miki-small-app.name" . }}
chart: {{ template "miki-small-app.chart" . }}
release: {{ .Release.Name }}
heritage: {{ .Release.Service }}
spec:
replicas: {{ .Values.replicaCount }}
selector:
matchLabels:
app: {{ template "miki-small-app.name" . }}
release: {{ .Release.Name }}
template:
metadata:
labels:
app: {{ template "miki-small-app.name" . }}
release: {{ .Release.Name }}
spec:
containers:
- name: {{ .Chart.Name }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: {{ .Values.image.pullPolicy }}
44. Helm - intro
also in our code is a reference to toYaml
this is for cases when our code is already in yaml format
for this to Yaml solves our issue with importing code
also in case where our code cannot be indented in the source
file we need to match the it to the resulting generated
yaml file we can pipe to an indent functions like so |indent NUM
we can also include function from our _helpers file
so for instance we define a code block in our template :
{{- define "my_labels" }}
labels:
generator: helm
date: {{ now | htmlDate }}
{{- end }}
and access it in our resource.yaml file like so
{{ template "mychart_app" . }}
or use the include function in the template function the code is added as as and in include its proccesd
as a function .
{{ toYaml .Values.resources | indent 12 }}
{{- with .Values.nodeSelector }}
nodeSelector:
{{ toYaml . | indent 8 }}
{{- end }}
{{- with .Values.affinity }}
affinity:
{{ toYaml . | indent 8 }}
{{- end }}
{{- with .Values.tolerations }}
tolerations:
{{ toYaml . | indent 8 }}
{{- end }}
45. Helm- Lab
To install helm download the release from here
https://storage.googleapis.com/kubernetes-helm/helm-v2.9.1-linux-amd64.tar.gz
Unpack on node 1 and run helm init
Once it's done run helm install