EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`The chart below illustrates infringement of the Medeiros ’419 Patent by Defendant Netflix, Inc.’s (“Netflix”) distributed computing
`and microservices platforms, including those implemented using Netflix’s Titus container-management platform (the “Accused
`Instrumentalities”).
`
`This chart is preliminary and based on information presently available to Plaintiffs CA, Inc. and Avago Technologies International
`Sales Pte. Limited. Netflix has yet to produce any documents, materials, or other discovery responses in this matter. Notably, Plaintiffs
`do not currently have access in this case to the internal technical documentation and source code associated with the Accused
`Instrumentalities. This infringement chart was therefore made without the benefit of these materials. Plaintiffs expressly reserve the
`right to amend this infringement chart as additional documents, materials, and information becomes available to Plaintiffs, including
`but not limited to the internal technical documentation and source code described above.
`
`These contentions are not an admission of any kind, including with regard to claim construction, as claim construction proceedings
`have not yet occurred. Plaintiffs expressly reserve the right to amend these contentions based on the outcome of those proceedings.
`This claim chart is exemplary in nature, and merely designed to put Netflix on notice of Plaintiffs’ current infringement contentions.
`
`Claim Language
`1. An apparatus,
`comprising a first node
`of a network, the first
`node comprising:
`
`Contentions
`The preamble of this claim is not limiting. If the preamble is found to be limiting, the Accused
`Instrumentalities include an apparatus, comprising a first node of a network.
`
`Architecture
`
`Titus is a framework on top of Apache Mesos, a cluster-management system
`that brokers available resources across a fleet of machines. Titus consists of
`a replicated, leader-elected scheduler called Titus Master, which handles the
`placement of containers onto a large pool of EC2 virtual machines called
`Titus Agents, which manage each container's life cycle. Zookeeper manages
`leader election, and Cassandra persists the master's data. The Titus
`architecture is shown below.
`
`Page 1 of 93
`
`Netflix, Inc. - Ex. 1019, Page 000001
`IPR2022-00322 (Netflix, Inc. v. CA, Inc.)
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`
`Work in Titus is described by a job specification that details what to run
`(e.g., a container image and entry point), metadata (e.g., the job's purpose
`and who owns it), and what resources are required to run it, such as CPU,
`memory, or scheduling constraints (e.g., availability zone balancing or host
`affinity). Job specifications are submitted to the master and consist of a
`number of tasks that represent an individual instance of a running
`application. The master schedules tasks onto Titus agents that launch
`containers based on the task's job specification.
`
`Components
`
`Titus Gateway
`
`
`
`Page 2 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000002
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`The Titus Gateway is a scalable API tier that handles direct requests from
`clients and users. The Gateway exposes gRPC and REST APIs, handles
`connection management, and performs validation.
`
`Titus Master
`
`The Titus Master is responsible for persisting job and task information,
`scheduling tasks, and managing the pool of EC2 Agents. The Master
`receives requests from Gateway instances and creates and persists job and
`task info in response. The Master schedules tasks onto Agents with
`available resources and scales the pool of Titus Agents up or down in
`response to demand.
`
`Titus Agent
`
`Titus Agents are responsible for setting up and running task containers and
`managing their lifecycle. The Agent sets up on host resources, such as
`storage and networking resources, and launches the container using Docker.
`The Agent monitors the task, reporting status and cleaning up resources
`when it completes.
`
`Overview, Titus, https://netflix.github.io/titus/overview/
`
`
`
`Page 3 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000003
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`
`
`
`
`
`
`Page 4 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000004
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`[1a] an interface
`operable to:
`communicate with a
`second node of the
`network; and
`
`
`Introduction to Virtual Kubelet – Featuring Titus by Netflix - Ria Bhatia & Sargun Dhillon, YouTube
`(Nov. 21, 2019), https://www.youtube.com/watch?v=eFnDwwckrKU
`
`The Accused Instrumentalities comprise a first node, comprising an interface operable to
`communicate with a second node of the network.
`
`Architecture
`
`Titus is a framework on top of Apache Mesos, a cluster-management system
`that brokers available resources across a fleet of machines. Titus consists of
`a replicated, leader-elected scheduler called Titus Master, which handles the
`placement of containers onto a large pool of EC2 virtual machines called
`Titus Agents, which manage each container's life cycle. Zookeeper manages
`
`
`
`Page 5 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000005
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`leader election, and Cassandra persists the master's data. The Titus
`architecture is shown below.
`
`
`Work in Titus is described by a job specification that details what to run
`(e.g., a container image and entry point), metadata (e.g., the job's purpose
`and who owns it), and what resources are required to run it, such as CPU,
`memory, or scheduling constraints (e.g., availability zone balancing or host
`affinity). Job specifications are submitted to the master and consist of a
`number of tasks that represent an individual instance of a running
`application. The master schedules tasks onto Titus agents that launch
`containers based on the task's job specification.
`
`Components
`
`
`
`Page 6 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000006
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`Titus Gateway
`
`The Titus Gateway is a scalable API tier that handles direct requests from
`clients and users. The Gateway exposes gRPC and REST APIs, handles
`connection management, and performs validation.
`
`Titus Master
`
`The Titus Master is responsible for persisting job and task information,
`scheduling tasks, and managing the pool of EC2 Agents. The Master
`receives requests from Gateway instances and creates and persists job and
`task info in response. The Master schedules tasks onto Agents with
`available resources and scales the pool of Titus Agents up or down in
`response to demand.
`
`Titus Agent
`
`Titus Agents are responsible for setting up and running task containers and
`managing their lifecycle. The Agent sets up on host resources, such as
`storage and networking resources, and launches the container using Docker.
`The Agent monitors the task, reporting status and cleaning up resources
`when it completes.
`
`Overview, Titus, https://netflix.github.io/titus/overview/
`
`
`
`Page 7 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000007
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`A Series of Unfortunate Container Events, https://qconnewyork.com/system/files/presentation-
`slides/netflix-containers-qconnyc2017.pdf
`
`
`
`
`
`Page 8 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000008
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`
`Running Containers at Scale at Netflix, at 16, available at https://www.slideshare.net/aspyker/container-
`world-2018
`
`A Common Network is Key
`
`An important enabler for many of the integrations was a common
`networking infrastructure. Seamless network communication between
`containerized applications and existing infrastructure removed many
`integration and adoption hurdles.
`
`. . .
`
`Titus provides a unique IP address to each container by connecting
`containers to the same AWS Virtual Private Cloud (VPC) network to which
`VMs are connected. Using a common VPC allows containers to share the
`same IP address space as VMs and use the same networking policies and
`
`
`
`Page 9 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000009
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`features such as AWS SGs (Security Groups). This approach avoids the
`need to manage ports, as each container gets its own IP and full port range,
`and network gateways.
`
`When launching a container that requested a routable IP address, Titus
`attaches an AWS ENI (Elastic Network Interface)2 to the agent VM that is
`running the container. Attaching an ENI creates a new network interface on
`the VM from which multiple IP addresses can be assigned. These addresses
`are allocated from the same CIDR (classless inter-domain routing) range as
`VMs in the VPC, meaning containers and VMs can directly address each
`other's IPs. Allocating IPs via ENIs lets Titus avoid managing the available
`VPC IPs or directly modifying VPC routing tables.
`
`When Titus is preparing to launch a new container, it creates a network
`namespace for it, assigns it a specific IP address from an ENI, and connects
`the container's network namespace to the host's using a veth (virtual
`Ethernet) interface. Routing rules on the host route all traffic for that IP to
`the veth interface, and routing rules within the network namespace
`configure the allocated IP for the container.
`
`Andrew Leung et al., Titus: Introducing Containers to the Netflix Cloud, 15 ACMQUEUE 5,
`https://queue.acm.org/detail.cfm?id=3158370
`
`The Accused Instrumentalities also include Titus Virtual Kubelet.
`
`
`
`Page 10 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000010
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`
`
`
`
`Page 11 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000011
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`
`
`
`
`Page 12 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000012
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`
`Introduction to Virtual Kubelet – Featuring Titus by Netflix - Ria Bhatia & Sargun Dhillon, YouTube
`(Nov. 21, 2019), https://www.youtube.com/watch?v=eFnDwwckrKU
`
`Nodes
`
`Kubernetes runs your workload by placing containers into Pods to run
`on Nodes. A node may be a virtual or physical machine, depending on the
`cluster. Each node is managed by the control plane and contains the services
`necessary to run Pods
`
`Typically you have several nodes in a cluster; in a learning or resource-
`limited environment, you might have only one node.
`
`
`
`Page 13 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000013
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`The components on a node include the kubelet, a container runtime, and
`the kube-proxy.
`
`https://kubernetes.io/docs/concepts/architecture/nodes/
`
`Node Components
`
`Node components run on every node, maintaining running pods and
`providing the Kubernetes runtime environment.
`
`kubelet
`
`that runs on each node in
`An agent
`that containers are running in a Pod.
`
`the cluster. It makes sure
`
`The kubelet takes a set of PodSpecs that are provided through various
`mechanisms and ensures that the containers described in those PodSpecs
`are running and healthy. The kubelet doesn't manage containers which were
`not created by Kubernetes.
`
`kube-proxy
`
`kube-proxy is a network proxy that runs on each node in your cluster,
`implementing part of the Kubernetes Service concept.
`
`kube-proxy maintains network rules on nodes. These network rules allow
`network communication to your Pods from network sessions inside or
`outside of your cluster.
`
`kube-proxy uses the operating system packet filtering layer if there is one
`and it's available. Otherwise, kube-proxy forwards the traffic itself.
`
`Container runtime
`
`
`
`Page 14 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000014
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`The container runtime is the software that is responsible for running
`containers.
`
`Kubernetes supports several container runtimes: Docker, containerd, CRI-
`O, and any implementation of the Kubernetes CRI (Container Runtime
`Interface).
`
`https://kubernetes.io/docs/concepts/overview/components/#node-components
`
`How kubelets usually work
`
`Ordinarily, Kubernetes kubelets implement Pod and container operations
`for each Kubernetes Node. They run as an agent on each Node, whether that
`Node is a physical server or a virtual machine, and handles Pod/container
`operations on that Node. kubelets take a configuration called a PodSpec as
`input and work to ensure that containers specified in the PodSpec are
`running and healthy.
`
`How Virtual Kubelet works
`
`server, Virtual
`the Kubernetes API
`standpoint of
`the
`From
`Kubelets seem like normal kubelets, but with the crucial difference that they
`scheduler containers elsewhere, for example in a cloud serverless API, and
`not on the Node.
`
`Figure 1 below shows a Kubernetes cluster with a series of standard
`kubelets and one Virtual Kubelet:
`
`
`
`Page 15 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000015
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`[1b] one or more
`processors operable to:
`
`
`
`https://virtual-kubelet.io/docs/architecture/
`
`The Accused Instrumentalities comprise a first node, comprising one or more processors.
`
`Spinnaker
`
`We deploy Titus via Spinnaker to an EC2 cloud provider. Eventually we
`may release these pipelines, but for now we suggest direct deployments
`using the AWS EC2 console.
`
`
`
`Page 16 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000016
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`Required, Titus, https://netflix.github.io/titus/install/prereqs/
`
`AWS re:Invent 2018: Another Week, Another Million Containers on Amazon EC2 (CMP376),
`YouTube (Nov. 30, 2018), available at https://www.youtube.com/watch?v=5IsrZZSUQeU
`
`
`
`
`
`Page 17 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000017
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`
`New – Next Generation (R4) Memory-Optimized EC2 Instances, AWS News Blog (Nov. 30, 2016),
`https://aws.amazon.com/blogs/aws/new-next-generation-r4-memory-optimized-ec2-instances/
`
`
`
`
`
`Page 18 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000018
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`https://aws.amazon.com/ec2/?ec2-whats-new.sort-by=item.additionalFields.postDateTime&ec2-whats-
`new.sort-order=desc
`
`The Accused Instrumentalities comprise one or more processors operable to tell a plurality of nodes
`to perform an operation comprising a procedure of an application, the plurality of nodes comprising
`the second node and one or more additional nodes.
`
`[1c] tell a plurality of
`nodes to perform an
`operation comprising a
`procedure of an
`application, the plurality
`of nodes comprising
`[the] second node and
`one or more additional
`nodes;
`
`
`Introduction to Virtual Kubelet – Featuring Titus by Netflix - Ria Bhatia & Sargun Dhillon, YouTube
`(Nov. 21, 2019), https://www.youtube.com/watch?v=eFnDwwckrKU
`
`
`
`
`
`Page 19 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000019
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`Work in Titus is described by a job specification that details what to run
`(e.g., a container image and entry point), metadata (e.g., the job's purpose
`and who owns it), and what resources are required to run it, such as CPU,
`memory, or scheduling constraints (e.g., availability zone balancing or host
`affinity). Job specifications are submitted to the master and consist of a
`number of tasks that represent an individual instance of a running
`application. The master schedules tasks onto Titus agents that launch
`containers based on the task's job specification.
`
`. . .
`
`Titus Gateway
`
`The Titus Gateway is a scalable API tier that handles direct requests from
`clients and users. The Gateway exposes gRPC and REST APIs, handles
`connection management, and performs validation.
`
`Overview, Titus, https://netflix.github.io/titus/overview/
`
`curl localhost:7001/api/v3/jobs \
` -X POST -H "Content-type: application/json" -d \
`'{
` "owner": {
` "teamEmail": "me@example.com"
` },
` "applicationName": "myServiceApp",
` "capacityGroup": "myServiceApp",
` "jobGroupInfo": {
` "stack": "myStack",
` "detail": "detail",
` "sequence": "002"
` },
` "attributes": {
` "key1": "value1"
` },
` "container": {
` "resources": {
`
`
`
`Page 20 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000020
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
` "cpu": 1.0,
` "memoryMB": 128,
` "diskMB": 100,
` "networkMbps": 128,
` "allocateIP": true
` },
` "securityProfile": {
` "securityGroups": [
` "sg-<PRIVATE>"
` ],
` "iamRole": "arn:aws:iam::<PRIVATE>:role/titusappwiths3InstanceProfile"
` },
` "image": {
` "name": "tutum/nginx",
` "tag": "latest"
` },
` "env": {
` "MY_ENV": "myEnv"
` },
` "softConstraints": {
` "constraints": {
` "UniqueHost": "true",
` "ZoneBalance": "true"
` }
` },
` "hardConstraints": {}
` },
` "service": {
` "capacity": {
` "min": 1,
` "max": 1,
` "desired": 1
` },
` "enabled": true,
` "retryPolicy": {
` "delayed": {
` "delayMs": "1000"
` }
` },
` "migrationPolicy": {
` "selfManaged": {}
`
`
`
`Page 21 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000021
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
` }
` }
`}'
`https://github.com/angelbarrera92/titus-terraform
`
`Workloads
`
`A workload is an application running on Kubernetes. Whether your
`workload is a single component or several that work together, on
`Kubernetes you run it inside a set of pods. In Kubernetes, a Pod represents
`a set of running containers on your cluster.
`
`Kubernetes pods have a defined lifecycle. For example, once a pod is
`running in your cluster then a critical fault on the node where that pod is
`running means that all the pods on that node fail. Kubernetes treats that level
`of failure as final: you would need to create a new Pod to recover, even if
`the node later becomes healthy.
`
`However, to make life considerably easier, you don't need to manage
`each Pod directly. Instead, you can use workload resources that manage a
`set of pods on your behalf. These resources configure controllers that make
`sure the right number of the right kind of pod are running, to match the state
`you specified.
`
`Kubernetes provides several built-in workload resources:
`
`legacy
`the
`• Deployment and ReplicaSet (replacing
`resource ReplicationController). Deployment is a good fit for
`managing a stateless application workload on your cluster, where
`any Pod in the Deployment is interchangeable and can be replaced
`if needed.
`
`• StatefulSet lets you run one or more related Pods that do track state
`somehow. For example, if your workload records data persistently,
`
`
`
`Page 22 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000022
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`each Pod with
`a StatefulSet that matches
`run
`can
`you
`the Pods for
`in
`a PersistentVolume. Your
`code,
`running
`that StatefulSet,
`can
`replicate data
`to other Pods in
`the
`same StatefulSet to improve overall resilience.
`
`• DaemonSet defines Pods that provide node-local facilities. These
`might be fundamental to the operation of your cluster, such as a
`networking
`helper
`tool,
`or
`be
`part
`of
`an add-on.
`Every time you add a node to your cluster that matches the
`specification in a DaemonSet, the control plane schedules a Pod for
`that DaemonSet onto the new node.
`
`• Job and CronJob define tasks that run to completion and then stop.
`Jobs represent one-off tasks, whereas CronJobs recur according to a
`schedule.
`
`In the wider Kubernetes ecosystem, you can find third-party workload
`resources that provide additional behaviors. Using a custom resource
`definition, you can add in a third-party workload resource if you want a
`specific behavior that's not part of Kubernetes' core. For example, if you
`wanted to run a group of Pods for your application but stop work
`unless all the Pods are available (perhaps for some high-throughput
`distributed task), then you can implement or install an extension that does
`provide that feature.
`
`https://kubernetes.io/docs/concepts/workloads/
`
`Pods
`
`Pods are the smallest deployable units of computing that you can create and
`manage in Kubernetes.
`
`A Pod (as in a pod of whales or pea pod) is a group of one or
`more containers, with shared storage and network resources, and a
`
`
`
`Page 23 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000023
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`specification for how to run the containers. A Pod's contents are always co-
`located and co-scheduled, and run in a shared context. A Pod models an
`application-specific "logical host": it contains one or more application
`containers which are relatively tightly coupled. In non-cloud contexts,
`applications executed on the same physical or virtual machine are analogous
`to cloud applications executed on the same logical host.
`
`As well as application containers, a Pod can contain init containers that run
`during Pod startup. You can also inject ephemeral containers for debugging
`if your cluster offers this.
`
`https://kubernetes.io/docs/concepts/workloads/pods/
`
`Containers
`
`Each container that you run is repeatable; the standardization from having
`dependencies included means that you get the same behavior wherever you
`run it.
`
`Containers decouple applications from underlying host infrastructure. This
`makes deployment easier in different cloud or OS environments.
`
`Container images
`
`image is a ready-to-run software package, containing
`A container
`everything needed to run an application: the code and any runtime it
`requires, application and system libraries, and default values for any
`essential settings.
`
`By design, a container is immutable: you cannot change the code of a
`container that is already running. If you have a containerized application
`and want to make changes, you need to build a new image that includes the
`change, then recreate the container to start from the updated image.
`
`
`
`Page 24 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000024
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`Container runtimes
`
`The container runtime is the software that is responsible for running
`containers.
`
`Kubernetes supports several container runtimes: Docker, containerd, CRI-
`O, and any implementation of the Kubernetes CRI (Container Runtime
`Interface).
`
`https://kubernetes.io/docs/concepts/containers/
`
`Images
`
`A container image represents binary data that encapsulates an application
`and all its software dependencies. Container images are executable software
`bundles that can run standalone and that make very well defined
`assumptions about their runtime environment.
`
`You typically create a container image of your application and push it to a
`registry before referring to it in a Pod
`
`This page provides an outline of the container image concept.
`
`Image names
`
`such
`name
`a
`given
`usually
`are
`images
`Container
`as pause, example/mycontainer, or kube-apiserver. Images can also include
`a registry hostname; for example: fictional.registry.example/imagename,
`and
`possibly
`a
`port
`number
`as
`well;
`for
`example: fictional.registry.example:10443/imagename.
`
`If you don't specify a registry hostname, Kubernetes assumes that you mean
`the Docker public registry.
`
`
`
`Page 25 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000025
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`[1d] instruct the plurality
`of nodes how to perform
`the operation using
`computer code; and
`
`After the image name part you can add a tag (as also using with commands
`such as docker and podman). Tags let you identify different versions of the
`same series of images.
`
`Image tags consist of lowercase and uppercase letters, digits, underscores
`(_),
`periods
`(.),
`and
`dashes
`(-).
`There are additional rules about where you can place the separator
`characters
`(_, -,
`and .)
`inside
`an
`image
`tag.
`If you don't specify a tag, Kubernetes assumes you mean the tag latest.
`
`https://kubernetes.io/docs/concepts/containers/images/
`
`The Accused Instrumentalities comprise one or more processors operable to instruct the plurality of
`nodes how to perform the operation using computer code.
`
`With Titus, our batch users are able to put together sophisticated
`infrastructure quickly due to having to only specify resource requirements.
`Users no longer have to deal with choosing and maintaining AWS EC2
`instance sizes that don’t always perfectly fit their workload. Users trust
`Titus to pack larger instances efficiently across many workloads. Batch
`users develop code locally and then immediately schedule it for scaled
`execution on Titus. Using containers, Titus runs any batch application
`letting the user specify exactly what application code and dependencies are
`needed. For example, in machine learning training we have users running a
`mix of Python, R, Java and bash script applications.
`
`. . .
`
`Titus Details
`
`We have already covered what led us to build Titus. Now, let’s dig into the
`details of how Titus provides these values. We will provide a brief overview
`
`
`
`Page 26 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000026
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`of how Titus scheduling and container execution supports the service and
`batch job requirements as shown in the below diagram.
`
`
`
`Titus System Level View
`
`Titus supports both service jobs that run “forever” and batch jobs that run
`“until done”.
`
`Service jobs restart failed instances and are autoscaled to maintain a
`changing level of load. Batch jobs are retried according to policy and run to
`completion.
`
`Titus offers multiple SLA’s for resource scheduling. Titus offers on-
`demand capacity for ad hoc batch and non-critical internal services by
`autoscaling capacity in EC2 based on current needs. Titus also offers pre-
`provisioned guaranteed capacity for user facing workloads and more critical
`batch. The scheduler does both bin packing for efficiency across larger
`virtual machines and anti-affinity for reliability spanning virtual machines
`and availability zones. The foundation of this scheduling is a Netflix open
`source library called Fenzo.
`
`
`
`Page 27 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000027
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`https://netflixtechblog.com/the-evolution-of-container-usage-at-netflix-3abfc096781b
`
`Work in Titus is described by a job specification that details what to run
`(e.g., a container image and entry point), metadata (e.g., the job's purpose
`and who owns it), and what resources are required to run it, such as CPU,
`memory, or scheduling constraints (e.g., availability zone balancing or host
`affinity). Job specifications are submitted to the master and consist of a
`number of tasks that represent an individual instance of a running
`application. The master schedules tasks onto Titus agents that launch
`containers based on the task's job specification.
`
`Overview, Titus, https://netflix.github.io/titus/overview/
`
`curl -X POST --header 'Content-Type: application/json' --header 'Accept:
`application/json' -d '{
` "applicationName": "library/ubuntu",
` "version": "latest",
` "type": "batch",
` "entryPoint": "sleep 10",
` "instances": 1,
` "cpu": 1,
` "memory": 1024,
` "disk": 1000,
` "networkMbps": 128
` }' 'http://GATEWAYIP:7001/api/v2/jobs'
`https://netflix.github.io/titus/test/batch/
`
`Titus
`
`Titus is a container management platform that provides scalable and reliable
`container execution and cloud-native integration with Amazon AWS. Titus
`was built internally at Netflix and is used in production to power Netflix
`streaming, recommendation, and content systems.
`
`
`
`Page 28 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000028
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`Titus provides the following:
`
`• A production ready container platform. Titus is run in production
`at Netflix, managing thousands of AWS EC2 instances and
`launching hundreds of thousands of containers daily for both batch
`and service workloads.
`
`• Cloud-native integrations with AWS. Titus integrates with AWS
`services, such as VPC networking, IAM and Security Group
`concepts, Application Load Balancing, and EC2 capacity
`management. These integrations enable many cloud services to
`work seamlessly with containers.
`
`• Netflix OSS integration. Titus works natively with many existing
`including Spinnaker, Eureka, Archaius,
`Netflix OSS projects,
`and Atlas among others.
`
`• Docker-native container execution. Titus can run
`images
`packaged as Docker containers while providing additional security
`and reliability around container execution.
`
`https://netflix.github.io/titus/
`
`Docker objects
`
`When you use Docker, you are creating and using images, containers,
`networks, volumes, plugins, and other objects. This section is a brief
`overview of some of those objects.
`
`IMAGES
`
`An image is a read-only template with instructions for creating a Docker
`container. Often, an image is based on another image, with some additional
`customization. For example, you may build an image which is based on
`
`
`
`Page 29 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000029
`
`

`

`EXHIBIT B—INFRINGEMENT CONTENTION CHART FOR U.S. PATENT NO. 8,656,419 (the “Medeiros ’419 Patent”)
`
`the ubuntu image, but installs the Apache web server and your application,
`as well as the configuration details needed to make your application run.
`
`You might create your own images or you might only use those created by
`others and published in a registry. To build your own image, you create
`a Dockerfile with a simple syntax for defining the steps needed to create the
`image and run it. Each instruction in a Dockerfile creates a layer in the
`image. When you change the Dockerfile and rebuild the image, only those
`layers which have changed are rebuilt. This is part of what makes images
`so lightweight, small, and fast, when compared to other virtualization
`technologies.
`
`CONTAINERS
`
`A container is a runnable instance of an image. You can create, start, stop,
`move, or delete a container using the Docker API or CLI. You can connect
`a container to one or more networks, attach storage to it, or even create a
`new image based on its current state.
`
`By default, a container is relatively well isolated from other containers and
`its host machine. You can control how isolated a container’s network,
`storage, or other underlying subsystems are from other containers or from
`the host machine.
`
`A container is defined by its image as well as any configuration options you
`provide to it when you create or start it. When a container is removed, any
`changes to its state that are not stored in persistent storage disappear.
`
`Docker Overview, Docker Docs, https://docs.docker.com/get-started/overview/
`
`Pods
`
`Pods are the smallest deployable units of computing that you can create and
`manage in Kubernetes.
`
`
`
`Page 30 of 93
`
`
`
`
`
`Netflix, Inc. - Ex. 1019, Page 000030
`
`

`

`EXHIBIT B—INFRINGEMEN