Speaker: Scott Nichols One of the techniques developed inside the Knative Project is the concept of duck typing control plane resources. This enables a loose coupling not only between Knative and third party extensions, but between the Knative components themselves. Duck typing is broadly applicable to the Kubernetes ecosystem as a way to enable this loose coupling, and we are seeing interest and adoption in projects like Cluster API, Crossplane, and many others. Let's look at some examples and then deep dive to understand how this works and how you might leverage the techniques yourself.

1. Knative Outro
n3wscott@knative.team
@n3wscott ( , , )

2. Who am I?
● Riot Games (2012 - 2015)
○ Thrown under the bus to work on an emerging infra project (chef targeting VMs)
● Google (2015 - 2019)
○ Tried my hand at desktop apps, Chrome. Thought about farming instead.
○ Transferred into Google Cloud, worked on OSS - Kubernetes Service Catalog
■ I joined when the project was still an aggregated API server, made the case for CRDs
○ Fought hard for the team to pivot to the “Kubernetes Resource Model”
■ End result: Google Config Connector.
○ Bounced out before it got going, thought the world needed Knative First.
■ Landed in Knative Eventing.
■ Started the Eventing Sources Working Group.
■ Became a Productivity Working group leave several months ago.
● VMware (2019 - present)
○ Keeping the Knative OSS dreams alive.
■ Vote for me! I am running for Knative ToC 2021 :D

3. What is duck typing? “If it looks like a duck, swims like a duck, and
quacks like a duck, then it probably is a duck.”
In computer science, there are two ways to implement interfaces, the direct way, like Java:
public interface Animal {...}
public class Mammal implements Animal {...}
type Animal interface {...}
type Mammal struct {...}
animal, ok := mammal.(Animal)
Or the inferred way, like Go:
Both ways let the integrator interact with objects through a contract, duck typing allows for
the implementation to not be aware of that contract, and the integrator to not need to be
fully aware of the implementation.

4. Other kinds of duck typing?
We also duck type on resource type negotiation, like the double decode JSON pattern:
1. Receive some JSON
2. Decode that JSON into a common base object and inspect it, extract a type hint.
3. Use the type hint to further decode it into a known type.
{
“type”: “foo.bar.baz”,
“foo”: “abc”,
“bar”: 123,
“baz”: [“one”, “two”]
}
struct base type {
Type string
}
struct fooBarBaz type {
Type string
Foo string
Bar int
Baz []string
}
1
2
3
Here, base is the duck type, the contract to get type.

5. Duck Typing in Kubernetes

6. Case Study: Cluster API
Required status fields
The InfrastructureCluster object must have a status object.
The spec object must have the following fields defined:
● controlPlaneEndpoint - identifies the endpoint used to
connect to the target’s cluster apiserver.
The status object must have the following fields defined:
● ready - a boolean field that is true when the infrastructure is
ready to be used.
kind: MyProviderCluster
apiVersion:
infrastructure.cluster.x-k8s.io/v1alpha3
spec:
controlPlaneEndpoint:
host: example.com
port: 6443
status:
ready: true
Contract
Instance
https://cluster-api.sigs.k8s.io/developer/architecture/controllers/cluster.html

7. Case Study: KEDA
// WithTriggers is a specification for a resource with triggers
type WithTriggers struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec WithTriggersSpec `json:"spec"`
}
// WithTriggersSpec is the spec for a an object with triggers resource
type WithTriggersSpec struct {
PollingInterval *int32 `json:"pollingInterval
Triggers []ScaleTriggers `json:"triggers"`
}
apiVersion: keda.sh/v1alpha1
kind: ScaledJob
metadata:
name: azure-storage-queue-consumer
namespace: default
spec:
jobTargetRef:
template:
spec:
containers:
- name: azure-storage-queue-receive
image: azure-storage-queue-client:dev
imagePullPolicy: Always
command: ["receive"]
envFrom:
- secretRef:
name: azure-storage-queue-secret
restartPolicy: Never
backoffLimit: 4
triggers:
- type: azure-queue
authenticationRef:
name: azure-queue-auth
metadata:
queueName: "hello"
Contract
Instance
https://github.com/kedacore/sample-go-storage-queue/

8. Case Study: Knative Addressable
apiVersion: group/version
kind: Kind
status:
address:
url: http://host/path?query
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
name: colors
namespace: default
spec: ...
status:
address:
url: http://colors.default.svc.cluster.local
conditions:
- lastTransitionTime: "2021-04-23T22:43:48Z"
status: "True"
type: Ready
- ...
latestCreatedRevisionName: colors-00005
latestReadyRevisionName: colors-00005
observedGeneration: 9
...
Contract
Instance
https://github.com/knative/docs/blob/main/docs/concepts/_index.md

9. Full Picture
Components:
● Control Plane Contract (Shape of resource)
● Behavioural Contract (how it should interpret or express that contract)
● RBAC, Using an Aggregated Role.
🦆 Controller
Service Account
Role Binding
+ Label Selector
Role X
Role Y
Role Z

10. Duck Typing in Action

11. Results Contract
type Results struct {
Expression string `json:"expression,omitempty"`
Result int `json:"result"`
}
type ResultsType struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Status ResultsStatus `json:"status"`
}
type ResultsStatus struct {
Results `json:",inline"`
}
`status.expression` is the human
readable form of the equation
represented by the resource
instance.
`status.result` is a numerical result
of the expression.

12. Results Contract
apiVersion: maths.tableflip.dev/v1alpha1
kind: Add
metadata:
name: add-few
spec:
add:
- value: 1
- value: 2
- value: 3
- value: 4
status:
conditions:
- lastTransitionTime: "2021-04-26T21:21:52Z"
status: "True"
type: Ready
expression: 1 + 2 + 3 + 4
observedGeneration: 1
result: 10
Add as duck type of the Results Contract

13. Add contract
Ref points to a resource that
implements the Results duck type.
Add is also a Results duck type.
This lets us view a resource as a
Results but also point at resources
that the operator has claimed are also
Results.
The controller that realizes Add knows
only the duck type contract when
inspecting the object Ref points at.
apiVersion: maths.tableflip.dev/v1alpha1
kind: Add
metadata:
name: add-refs
spec:
add:
- value: 1
- ref:
name: add-one
namespace: default
kind: Add
apiVersion: maths.tableflip.dev/v1alpha1
- ref:
name: add-few
namespace: default
kind: Add
apiVersion: maths.tableflip.dev/v1alpha1

14. apiVersion: maths.tableflip.dev/v1alpha1
kind: Subtract
metadata:
name: minus-7
spec:
sub:
- ref:
name: 3-plus
namespace: default
kind: Add
apiVersion: maths.tableflip.dev/v1alpha1
- value: 7
status:
conditions:...
expression: (3 + (1 + 2)) - 7
observedGeneration: 1
result: -1
apiVersion: maths.tableflip.dev/v1alpha1
kind: Add
metadata:
name: one-two
spec:
add:
- value: 1
- value: 2
status:
conditions:...
expression: 1 + 2
observedGeneration: 1
result: 3
apiVersion: maths.tableflip.dev/v1alpha1
kind: Add
metadata:
name: 3-plus
spec:
add:
- value: 3
- ref:
name: one-two
namespace: default
kind: Add
apiVersion: maths.tableflip.dev/v1alpha1
status:
conditions:...
expression: 3 + (1 + 2)
observedGeneration: 1
result: 6

15. Let’s make a duck.

16. Knative Dependency
Injection

17. Definitions
● Controller
○ A standard shell around Reconciler, to provide required setup.
● Reconciler
○ Control plane business logic centered around a single resource.
● Client
○ A generated RESTful client for interacting with the Kubernetes API Server to do CRUD.
● Informer
○ Sets up static watches with the Client to a cache. Tells you when the resource you are
interested in has had an update.
● Lister
○ Similar to the Client but read only for the shared cache.

18. rec·on·cile, settle
(a disagreement).

19. rec·on·cile, make
changes to current
state to become
closer to desired
state.

20. Desired State
K8s
API
Server

21. Reconciler
K8s
API
Server
Controller
Client
🗝
Informers
Listers Reconciler
cache

22. Shared State
K8s
API
Server
Controller
Client
🗝
Informers
Listers Reconciler
cache

23. Steps to Reconcile
1. Create Clients
2. Create Informers and Listers from that Client
a. This builds a cache for that client and connects the Informers and Listers.
3. Provide those Informers, Listers and Clients to a Controller Constructor
4. Start threads for Informers
5. Start threads for Controllers

24. 1. Create Clients
2. Create Informers and Listers
from that Client
3. Provide those Informers,
Listers and Clients to a
Controller Constructor
4. Start threads for Informers
5. Start threads for Controllers

25. 1. Create Clients
2. Create Informers and Listers
from that Client
3. Provide those Informers,
Listers and Clients to a
Controller Constructor
4. Start threads for Informers
5. Start threads for Controllers

26. 1. Create Clients
2. Create Informers and Listers
from that Client
3. Provide those Informers,
Listers and Clients to a
Controller Constructor
4. Start threads for Informers
5. Start threads for Controllers

27. "These 200+ lines of
code will stay in-sync
with the rest of
Knative."
- no one

28. We want to write this:
K8s
API
Server
Controller
Client
🗝
Informers
Listers Reconciler
cache

29. We have to deal with these:
K8s
API
Server
Controller
Client
🗝
Informers
Listers Reconciler
cache

30. Main
makes
🗝🐌🐚
Controller
wants
🐌🐚
makes
💵⚒
🗝 - Creds
🐌 - Client
🐚 - Informer
💵 - Lister
⚒ - Reconciler

31. Dependency Graph
🗝
🗝 - Creds
🐌 - Client
🐚 - Informer
💵 - Lister
⚒ - Reconciler
🐌
🐚
💵
⚒

32. Needs Graph
🗝
🗝 - Creds
🐌 - Client
🐚 - Informer
💵 - Lister
⚒ - Reconciler
🐌
🐚
💵
⚒

33. Steps to Reconcile
1. Ask for Clients
2. Ask for Informers
a. These ask for Clients
3. Use Informers to make Listers
4. Provide those Informers, Listers and Clients to a Controller Constructor

36. We standardized how
Knative main methods
ask for creds and
setup configs.
So this code can all
be shared.

38. We standardized how
Knative controllers ask
for clients and
informers.
So this code can all
be generated.

39. Generated Client Injection Code