Re-enable EKS ENI CI

Cilium is a networking, observability, and security solution with an eBPF-based dataplane. It provides a simple flat Layer 3 network with the ability to span multiple clusters in either a native routing or overlay mode. It is L7-protocol aware and can enforce network policies on L3-L7 using an identity based security model that is decoupled from network addressing.

Cilium implements distributed load balancing for traffic between pods and to external services, and is able to fully replace kube-proxy, using efficient hash tables in eBPF allowing for almost unlimited scale. It also supports advanced functionality like integrated ingress and egress gateway, bandwidth management and service mesh, and provides deep network and security visibility and monitoring.

A new Linux kernel technology called eBPF is at the foundation of Cilium. It supports dynamic insertion of eBPF bytecode into the Linux kernel at various integration points such as: network IO, application sockets, and tracepoints to implement security, networking and visibility logic. eBPF is highly efficient and flexible. To learn more about eBPF, visit eBPF.io.

Stable Releases

The Cilium community maintains minor stable releases for the last three minor Cilium versions. Older Cilium stable versions from minor releases prior to that are considered EOL.

For upgrades to new minor releases please consult the Cilium Upgrade Guide.

Listed below are the actively maintained release branches along with their latest patch release, corresponding image pull tags and their release notes:

v1.15	2024-07-11	`quay.io/cilium/cilium:v1.15.7`	Release Notes
v1.14	2024-07-11	`quay.io/cilium/cilium:v1.14.13`	Release Notes
v1.13	2024-07-11	`quay.io/cilium/cilium:v1.13.18`	Release Notes

Architectures

Cilium images are distributed for AMD64 and AArch64 architectures.

Software Bill of Materials

Starting with Cilium version 1.13.0, all images include a Software Bill of Materials (SBOM). The SBOM is generated in SPDX format. More information on this is available on Cilium SBOM.

Development

For development and testing purpose, the Cilium community publishes snapshots, early release candidates (RC) and CI container images build from the main branch. These images are not for use in production.

For testing upgrades to new development releases please consult the latest development build of the Cilium Upgrade Guide.

Listed below are branches for testing along with their snapshots or RC releases, corresponding image pull tags and their release notes where applicable:

main	daily	`quay.io/cilium/cilium-ci:latest`	N/A
v1.16.0-rc.2	2024-07-15	`quay.io/cilium/cilium:v1.16.0-rc.2`	Release Candidate Notes

Functionality Overview

Protect and secure APIs transparently

Ability to secure modern application protocols such as REST/HTTP, gRPC and Kafka. Traditional firewalls operate at Layer 3 and 4. A protocol running on a particular port is either completely trusted or blocked entirely. Cilium provides the ability to filter on individual application protocol requests such as:

Allow all HTTP requests with method GET and path /public/.*. Deny all other requests.
Allow service1 to produce on Kafka topic topic1 and service2 to consume on topic1. Reject all other Kafka messages.
Require the HTTP header X-Token: [0-9]+ to be present in all REST calls.

See the section Layer 7 Policy in our documentation for the latest list of supported protocols and examples on how to use it.

Secure service to service communication based on identities

Modern distributed applications rely on technologies such as application containers to facilitate agility in deployment and scale out on demand. This results in a large number of application containers being started in a short period of time. Typical container firewalls secure workloads by filtering on source IP addresses and destination ports. This concept requires the firewalls on all servers to be manipulated whenever a container is started anywhere in the cluster.

In order to avoid this situation which limits scale, Cilium assigns a security identity to groups of application containers which share identical security policies. The identity is then associated with all network packets emitted by the application containers, allowing to validate the identity at the receiving node. Security identity management is performed using a key-value store.

Secure access to and from external services

Label based security is the tool of choice for cluster internal access control. In order to secure access to and from external services, traditional CIDR based security policies for both ingress and egress are supported. This allows to limit access to and from application containers to particular IP ranges.

Simple Networking

A simple flat Layer 3 network with the ability to span multiple clusters connects all application containers. IP allocation is kept simple by using host scope allocators. This means that each host can allocate IPs without any coordination between hosts.

The following multi node networking models are supported:

Overlay: Encapsulation-based virtual network spanning all hosts. Currently, VXLAN and Geneve are baked in but all encapsulation formats supported by Linux can be enabled.

When to use this mode: This mode has minimal infrastructure and integration requirements. It works on almost any network infrastructure as the only requirement is IP connectivity between hosts which is typically already given.
Native Routing: Use of the regular routing table of the Linux host. The network is required to be capable to route the IP addresses of the application containers.

When to use this mode: This mode is for advanced users and requires some awareness of the underlying networking infrastructure. This mode works well with:
- Native IPv6 networks
- In conjunction with cloud network routers
- If you are already running routing daemons

Load Balancing

Cilium implements distributed load balancing for traffic between application containers and to external services and is able to fully replace components such as kube-proxy. The load balancing is implemented in eBPF using efficient hashtables allowing for almost unlimited scale.

For north-south type load balancing, Cilium's eBPF implementation is optimized for maximum performance, can be attached to XDP (eXpress Data Path), and supports direct server return (DSR) as well as Maglev consistent hashing if the load balancing operation is not performed on the source host.

For east-west type load balancing, Cilium performs efficient service-to-backend translation right in the Linux kernel's socket layer (e.g. at TCP connect time) such that per-packet NAT operations overhead can be avoided in lower layers.

Bandwidth Management

Cilium implements bandwidth management through efficient EDT-based (Earliest Departure Time) rate-limiting with eBPF for container traffic that is egressing a node. This allows to significantly reduce transmission tail latencies for applications and to avoid locking under multi-queue NICs compared to traditional approaches such as HTB (Hierarchy Token Bucket) or TBF (Token Bucket Filter) as used in the bandwidth CNI plugin, for example.

Monitoring and Troubleshooting

The ability to gain visibility and troubleshoot issues is fundamental to the operation of any distributed system. While we learned to love tools like tcpdump and ping and while they will always find a special place in our hearts, we strive to provide better tooling for troubleshooting. This includes tooling to provide:

Event monitoring with metadata: When a packet is dropped, the tool doesn't just report the source and destination IP of the packet, the tool provides the full label information of both the sender and receiver among a lot of other information.
Metrics export via Prometheus: Key metrics are exported via Prometheus for integration with your existing dashboards.
Hubble: An observability platform specifically written for Cilium. It provides service dependency maps, operational monitoring and alerting, and application and security visibility based on flow logs.

Getting Started

What is eBPF and XDP?

Berkeley Packet Filter (BPF) is a Linux kernel bytecode interpreter originally introduced to filter network packets, e.g. for tcpdump and socket filters. The BPF instruction set and surrounding architecture have recently been significantly reworked with additional data structures such as hash tables and arrays for keeping state as well as additional actions to support packet mangling, forwarding, encapsulation, etc. Furthermore, a compiler back end for LLVM allows for programs to be written in C and compiled into BPF instructions. An in-kernel verifier ensures that BPF programs are safe to run and a JIT compiler converts the BPF bytecode to CPU architecture-specific instructions for native execution efficiency. BPF programs can be run at various hooking points in the kernel such as for incoming packets, outgoing packets, system calls, kprobes, uprobes, tracepoints, etc.

BPF continues to evolve and gain additional capabilities with each new Linux release. Cilium leverages BPF to perform core data path filtering, mangling, monitoring and redirection, and requires BPF capabilities that are in any Linux kernel version 4.8.0 or newer (the latest current stable Linux kernel is 4.14.x).

Many Linux distributions including CoreOS, Debian, Docker's LinuxKit, Fedora, openSUSE and Ubuntu already ship kernel versions >= 4.8.x. You can check your Linux kernel version by running uname -a. If you are not yet running a recent enough kernel, check the Documentation of your Linux distribution on how to run Linux kernel 4.9.x or later.

To read up on the necessary kernel versions to run the BPF runtime, see the section Prerequisites.

XDP is a further step in evolution and enables running a specific flavor of BPF programs from the network driver with direct access to the packet's DMA buffer. This is, by definition, the earliest possible point in the software stack, where programs can be attached to in order to allow for a programmable, high performance packet processor in the Linux kernel networking data path.

Further information about BPF and XDP targeted for developers can be found in the BPF and XDP Reference Guide.

To know more about Cilium, its extensions and use cases around Cilium and BPF take a look at Further Readings section.

Community

Slack

Join the Cilium Slack channel to chat with Cilium developers and other Cilium users. This is a good place to learn about Cilium, ask questions, and share your experiences.

Special Interest Groups (SIG)

See Special Interest groups for a list of all SIGs and their meeting times.

Developer meetings

The Cilium developer community hangs out on Zoom to chat. Everybody is welcome.

Weekly, Wednesday, 5:00 pm Europe/Zurich time (CET/CEST), usually equivalent to 8:00 am PT, or 11:00 am ET. Join Zoom
Third Wednesday of each month, 9:00 am Japan time (JST). Join Zoom

eBPF & Cilium Office Hours livestream

We host a weekly community YouTube livestream called eCHO which (very loosely!) stands for eBPF & Cilium Office Hours. Join us live, catch up with past episodes, or head over to the eCHO repo and let us know your ideas for topics we should cover.

Governance

The Cilium project is governed by a group of Maintainers and Committers. How they are selected and govern is outlined in our governance document.

Adopters

A list of adopters of the Cilium project who are deploying it in production, and of their use cases, can be found in file USERS.md.

Roadmap

Cilium maintains a public roadmap. It gives a high-level view of the main priorities for the project, the maturity of different features and projects, and how to influence the project direction.

License

The Cilium user space components are licensed under the Apache License, Version 2.0. The BPF code templates are dual-licensed under the General Public License, Version 2.0 (only) and the 2-Clause BSD License (you can use the terms of either license, at your option).

	if k.params.MultiCluster == "" {
	daemonSet, err := k.client.GetDaemonSet(ctx, k.params.CiliumNamespace, defaults.AgentDaemonSetName, metav1.GetOptions{})
	if err != nil {
	k.Log("❌ Unable to determine status of Cilium DaemonSet. Run \"cilium status\" for more details")
	return nil, fmt.Errorf("unable to determine status of Cilium DaemonSet: %w", err)
	}

	if daemonSet.Status.DesiredNumberScheduled == 1 && !k.params.SingleNode {
	k.Log("ℹ️ Single node environment detected, enabling single node connectivity test")
	k.params.SingleNode = true
	}

	func (k *K8sConnectivityCheck) deploy(ctx context.Context) error {
	var srcDeploymentNeeded, dstDeploymentNeeded bool

	if k.params.ForceDeploy {
	if err := k.deleteDeployments(ctx, k.clients.src); err != nil {
	return err
	}
	}

	_, err := k.clients.src.GetNamespace(ctx, k.params.TestNamespace, metav1.GetOptions{})
	if err != nil {
	srcDeploymentNeeded = true
	// In a single cluster environment, the source client is also
	// responsibel for destination deployments
	if k.params.MultiCluster == "" {
	dstDeploymentNeeded = true
	}
	k.Log("✨ [%s] Creating namespace for connectivity check...", k.clients.src.ClusterName())
	_, err = k.clients.src.CreateNamespace(ctx, k.params.TestNamespace, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create namespace %s: %s", k.params.TestNamespace, err)
	}
	}

	if k.params.MultiCluster != "" {
	if k.params.ForceDeploy {
	if err := k.deleteDeployments(ctx, k.clients.dst); err != nil {
	return err
	}
	}

	_, err = k.clients.dst.GetNamespace(ctx, k.params.TestNamespace, metav1.GetOptions{})
	if err != nil {
	dstDeploymentNeeded = true
	k.Log("✨ [%s] Creating namespace for connectivity check...", k.clients.dst.ClusterName())
	_, err = k.clients.dst.CreateNamespace(ctx, k.params.TestNamespace, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create namespace %s: %s", k.params.TestNamespace, err)
	}
	}
	}

	if srcDeploymentNeeded {
	k.Log("✨ [%s] Deploying echo-same-node service...", k.clients.src.ClusterName())
	svc := newService(echoSameNodeDeploymentName, map[string]string{"name": echoSameNodeDeploymentName}, serviceLabels, "http", 8080)
	_, err = k.clients.src.CreateService(ctx, k.params.TestNamespace, svc, metav1.CreateOptions{})
	if err != nil {
	return err
	}

	if k.params.MultiCluster != "" {
	k.Log("✨ [%s] Deploying echo-other-node service...", k.clients.src.ClusterName())
	svc := newService(echoOtherNodeDeploymentName, map[string]string{"name": echoOtherNodeDeploymentName}, serviceLabels, "http", 8080)
	svc.ObjectMeta.Annotations = map[string]string{}
	svc.ObjectMeta.Annotations["io.cilium/global-service"] = "true"

	_, err = k.clients.src.CreateService(ctx, k.params.TestNamespace, svc, metav1.CreateOptions{})
	if err != nil {
	return err
	}
	}

	echoDeployment := newDeployment(deploymentParameters{
	Name: echoSameNodeDeploymentName,
	Kind: kindEchoName,
	Port: 8080,
	Image: "quay.io/cilium/json-mock:1.2",
	Affinity: &corev1.Affinity{
	PodAffinity: &corev1.PodAffinity{
	RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{
	{
	LabelSelector: &metav1.LabelSelector{
	MatchExpressions: []metav1.LabelSelectorRequirement{
	{Key: "name", Operator: metav1.LabelSelectorOpIn, Values: []string{clientDeploymentName}},
	},
	},
	TopologyKey: "kubernetes.io/hostname",
	},
	},
	},
	},
	ReadinessProbe: newLocalReadinessProbe(8080, "/"),
	})

	_, err = k.clients.src.CreateDeployment(ctx, k.params.TestNamespace, echoDeployment, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create deployment %s: %s", echoSameNodeDeploymentName, err)
	}

	k.Log("✨ [%s] Deploying client service...", k.clients.src.ClusterName())
	clientDeployment := newDeployment(deploymentParameters{Name: clientDeploymentName, Kind: kindClientName, Port: 8080, Image: "quay.io/cilium/alpine-curl:1.0", Command: []string{"/bin/ash", "-c", "sleep 10000000"}})
	_, err = k.clients.src.CreateDeployment(ctx, k.params.TestNamespace, clientDeployment, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create deployment %s: %s", clientDeploymentName, err)
	}
	}

	if dstDeploymentNeeded {
	if !k.params.SingleNode \|\| k.params.MultiCluster != "" {
	k.Log("✨ [%s] Deploying echo-other-node service...", k.clients.dst.ClusterName())
	svc := newService(echoOtherNodeDeploymentName, map[string]string{"name": echoOtherNodeDeploymentName}, serviceLabels, "http", 8080)

	if k.params.MultiCluster != "" {
	svc.ObjectMeta.Annotations = map[string]string{}
	svc.ObjectMeta.Annotations["io.cilium/global-service"] = "true"
	}

	_, err = k.clients.dst.CreateService(ctx, k.params.TestNamespace, svc, metav1.CreateOptions{})
	if err != nil {
	return err
	}

	echoOtherNodeDeployment := newDeployment(deploymentParameters{
	Name: echoOtherNodeDeploymentName,
	Kind: kindEchoName,
	Port: 8080,
	Image: "quay.io/cilium/json-mock:1.2",
	Affinity: &corev1.Affinity{
	PodAntiAffinity: &corev1.PodAntiAffinity{
	RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{
	{
	LabelSelector: &metav1.LabelSelector{
	MatchExpressions: []metav1.LabelSelectorRequirement{
	{Key: "name", Operator: metav1.LabelSelectorOpIn, Values: []string{clientDeploymentName}},
	},
	},
	TopologyKey: "kubernetes.io/hostname",
	},
	},
	},
	},
	ReadinessProbe: newLocalReadinessProbe(8080, "/"),
	})

	_, err = k.clients.dst.CreateDeployment(ctx, k.params.TestNamespace, echoOtherNodeDeployment, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create deployment %s: %s", echoOtherNodeDeploymentName, err)
	}
	}
	}

	return nil
	}

	func (k *K8sInstaller) Install(ctx context.Context) error {
	if err := k.autodetectAndValidate(ctx); err != nil {
	return err
	}

	switch k.flavor.Kind {
	case k8s.KindEKS:
	if _, err := k.client.GetDaemonSet(ctx, "kube-system", "aws-node", metav1.GetOptions{}); err == nil {
	k.Log("🔥 Deleting aws-node DaemonSet...")
	if err := k.client.DeleteDaemonSet(ctx, "kube-system", "aws-node", metav1.DeleteOptions{}); err != nil {
	return err
	}
	}
	case k8s.KindGKE:
	if k.params.NativeRoutingCIDR == "" {
	cidr, err := k.gkeNativeRoutingCIDR(ctx, k.client.ContextName())
	if err != nil {
	k.Log("❌ Unable to auto-detect GKE native routing CIDR. Is \"gcloud\" installed?")
	k.Log("ℹ️ You can set the native routing CIDR manually with --native-routing-cidr")
	return err
	}
	k.params.NativeRoutingCIDR = cidr
	}

	if err := k.deployResourceQuotas(ctx); err != nil {
	return err
	}

	case k8s.KindAKS:
	if k.params.Azure.ResourceGroupName == "" {
	k.Log("❌ Azure resoure group is required, please specify --azure-resource-group")
	return fmt.Errorf("missing Azure resource group name")
	}

	if err := k.createAzureServicePrincipal(ctx); err != nil {
	return err
	}
	}

	if err := k.installCerts(ctx); err != nil {
	return err
	}

	k.Log("🚀 Creating Service accounts...")
	if _, err := k.client.CreateServiceAccount(ctx, k.params.Namespace, k8s.NewServiceAccount(defaults.AgentServiceAccountName), metav1.CreateOptions{}); err != nil {
	return err
	}

	if _, err := k.client.CreateServiceAccount(ctx, k.params.Namespace, k8s.NewServiceAccount(defaults.OperatorServiceAccountName), metav1.CreateOptions{}); err != nil {
	return err
	}

	k.Log("🚀 Creating Cluster roles...")
	if _, err := k.client.CreateClusterRole(ctx, ciliumClusterRole, metav1.CreateOptions{}); err != nil {
	return err
	}

	if _, err := k.client.CreateClusterRoleBinding(ctx, k8s.NewClusterRoleBinding(defaults.AgentClusterRoleName, k.params.Namespace, defaults.AgentServiceAccountName), metav1.CreateOptions{}); err != nil {
	return err
	}

	if _, err := k.client.CreateClusterRole(ctx, operatorClusterRole, metav1.CreateOptions{}); err != nil {
	return err
	}

	if _, err := k.client.CreateClusterRoleBinding(ctx, k8s.NewClusterRoleBinding(defaults.OperatorClusterRoleName, k.params.Namespace, defaults.OperatorServiceAccountName), metav1.CreateOptions{}); err != nil {
	return err
	}

	if k.params.Encryption {
	if err := k.createEncryptionSecret(ctx); err != nil {
	return err
	}
	}

	k.Log("🚀 Creating ConfigMap...")
	if _, err := k.client.CreateConfigMap(ctx, k.params.Namespace, k.generateConfigMap(), metav1.CreateOptions{}); err != nil {
	return err
	}

	switch k.flavor.Kind {
	case k8s.KindGKE:
	k.Log("🚀 Creating GKE Node Init DaemonSet...")
	if _, err := k.client.CreateDaemonSet(ctx, k.params.Namespace, k.generateGKEInitDaemonSet(), metav1.CreateOptions{}); err != nil {
	return err
	}
	}

	k.Log("🚀 Creating Agent DaemonSet...")
	if _, err := k.client.CreateDaemonSet(ctx, k.params.Namespace, k.generateAgentDaemonSet(), metav1.CreateOptions{}); err != nil {
	return err
	}

	k.Log("🚀 Creating Operator Deployment...")
	if _, err := k.client.CreateDeployment(ctx, k.params.Namespace, k.generateOperatorDeployment(), metav1.CreateOptions{}); err != nil {
	return err
	}

	if k.params.Wait {
	k.Log("⌛ Waiting for Cilium to be installed...")
	collector, err := status.NewK8sStatusCollector(ctx, k.client, status.K8sStatusParameters{
	Namespace: k.params.Namespace,
	Wait: true,
	WaitDuration: k.params.WaitDuration,
	WarningFreePods: []string{defaults.AgentDaemonSetName, defaults.OperatorDeploymentName},
	})
	if err != nil {
	return err
	}

	s, err := collector.Status(ctx)
	if err != nil {
	if s != nil {
	fmt.Println(s.Format())
	}
	return err
	}
	}

	if k.params.RestartUnmanagedPods {
	if err := k.restartUnmanagedPods(ctx); err != nil {
	return err
	}
	}

	return nil
	}

	func (k *K8sConnectivityCheck) deploy(ctx context.Context) error {
	var srcDeploymentNeeded, dstDeploymentNeeded bool

	if k.params.ForceDeploy {
	if err := k.deleteDeployments(ctx, k.clients.src); err != nil {
	return err
	}
	}

	_, err := k.clients.src.GetNamespace(ctx, k.params.TestNamespace, metav1.GetOptions{})
	if err != nil {
	srcDeploymentNeeded = true
	// In a single cluster environment, the source client is also
	// responsibel for destination deployments
	if k.params.MultiCluster == "" {
	dstDeploymentNeeded = true
	}
	k.Log("✨ [%s] Creating namespace for connectivity check...", k.clients.src.ClusterName())
	_, err = k.clients.src.CreateNamespace(ctx, k.params.TestNamespace, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create namespace %s: %s", k.params.TestNamespace, err)
	}
	}

	if k.params.MultiCluster != "" {
	if k.params.ForceDeploy {
	if err := k.deleteDeployments(ctx, k.clients.dst); err != nil {
	return err
	}
	}

	_, err = k.clients.dst.GetNamespace(ctx, k.params.TestNamespace, metav1.GetOptions{})
	if err != nil {
	dstDeploymentNeeded = true
	k.Log("✨ [%s] Creating namespace for connectivity check...", k.clients.dst.ClusterName())
	_, err = k.clients.dst.CreateNamespace(ctx, k.params.TestNamespace, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create namespace %s: %s", k.params.TestNamespace, err)
	}
	}
	}

	if srcDeploymentNeeded {
	k.Log("✨ [%s] Deploying echo-same-node service...", k.clients.src.ClusterName())
	svc := newService(echoSameNodeDeploymentName, map[string]string{"name": echoSameNodeDeploymentName}, serviceLabels, "http", 8080)
	_, err = k.clients.src.CreateService(ctx, k.params.TestNamespace, svc, metav1.CreateOptions{})
	if err != nil {
	return err
	}

	if k.params.MultiCluster != "" {
	k.Log("✨ [%s] Deploying echo-other-node service...", k.clients.src.ClusterName())
	svc := newService(echoOtherNodeDeploymentName, map[string]string{"name": echoOtherNodeDeploymentName}, serviceLabels, "http", 8080)
	svc.ObjectMeta.Annotations = map[string]string{}
	svc.ObjectMeta.Annotations["io.cilium/global-service"] = "true"

	_, err = k.clients.src.CreateService(ctx, k.params.TestNamespace, svc, metav1.CreateOptions{})
	if err != nil {
	return err
	}
	}

	echoDeployment := newDeployment(deploymentParameters{
	Name: echoSameNodeDeploymentName,
	Kind: kindEchoName,
	Port: 8080,
	Image: "quay.io/cilium/json-mock:1.2",
	Affinity: &corev1.Affinity{
	PodAffinity: &corev1.PodAffinity{
	RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{
	{
	LabelSelector: &metav1.LabelSelector{
	MatchExpressions: []metav1.LabelSelectorRequirement{
	{Key: "name", Operator: metav1.LabelSelectorOpIn, Values: []string{clientDeploymentName}},
	},
	},
	TopologyKey: "kubernetes.io/hostname",
	},
	},
	},
	},
	ReadinessProbe: newLocalReadinessProbe(8080, "/"),
	})

	_, err = k.clients.src.CreateDeployment(ctx, k.params.TestNamespace, echoDeployment, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create deployment %s: %s", echoSameNodeDeploymentName, err)
	}

	k.Log("✨ [%s] Deploying client service...", k.clients.src.ClusterName())
	clientDeployment := newDeployment(deploymentParameters{Name: clientDeploymentName, Kind: kindClientName, Port: 8080, Image: "quay.io/cilium/alpine-curl:1.0", Command: []string{"/bin/ash", "-c", "sleep 10000000"}})
	_, err = k.clients.src.CreateDeployment(ctx, k.params.TestNamespace, clientDeployment, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create deployment %s: %s", clientDeploymentName, err)
	}
	}

	if dstDeploymentNeeded {
	if !k.params.SingleNode \|\| k.params.MultiCluster != "" {
	k.Log("✨ [%s] Deploying echo-other-node service...", k.clients.dst.ClusterName())
	svc := newService(echoOtherNodeDeploymentName, map[string]string{"name": echoOtherNodeDeploymentName}, serviceLabels, "http", 8080)

	if k.params.MultiCluster != "" {
	svc.ObjectMeta.Annotations = map[string]string{}
	svc.ObjectMeta.Annotations["io.cilium/global-service"] = "true"
	}

	_, err = k.clients.dst.CreateService(ctx, k.params.TestNamespace, svc, metav1.CreateOptions{})
	if err != nil {
	return err
	}

	echoOtherNodeDeployment := newDeployment(deploymentParameters{
	Name: echoOtherNodeDeploymentName,
	Kind: kindEchoName,
	Port: 8080,
	Image: "quay.io/cilium/json-mock:1.2",
	Affinity: &corev1.Affinity{
	PodAntiAffinity: &corev1.PodAntiAffinity{
	RequiredDuringSchedulingIgnoredDuringExecution: []corev1.PodAffinityTerm{
	{
	LabelSelector: &metav1.LabelSelector{
	MatchExpressions: []metav1.LabelSelectorRequirement{
	{Key: "name", Operator: metav1.LabelSelectorOpIn, Values: []string{clientDeploymentName}},
	},
	},
	TopologyKey: "kubernetes.io/hostname",
	},
	},
	},
	},
	ReadinessProbe: newLocalReadinessProbe(8080, "/"),
	})

	_, err = k.clients.dst.CreateDeployment(ctx, k.params.TestNamespace, echoOtherNodeDeployment, metav1.CreateOptions{})
	if err != nil {
	return fmt.Errorf("unable to create deployment %s: %s", echoOtherNodeDeploymentName, err)
	}
	}
	}

	return nil
	}

cilium / cilium-cli Goto Github PK

cilium-cli's Introduction

Stable Releases

Architectures

Software Bill of Materials

Development

Functionality Overview

Protect and secure APIs transparently

Secure service to service communication based on identities

Secure access to and from external services

Simple Networking

Load Balancing

Bandwidth Management

Monitoring and Troubleshooting

Getting Started

What is eBPF and XDP?

Community

Slack

Special Interest Groups (SIG)

Developer meetings

eBPF & Cilium Office Hours livestream

Governance

Adopters

Roadmap

License

cilium-cli's People

Contributors

Stargazers

Watchers

Forkers

cilium-cli's Issues

Recommend Projects

Recommend Topics

Recommend Org

Jobs