LFX Mentorship 2026_01 test task

[antoninbas]

First, we'd like to thank everyone who is interested in taking part to the LFX Mentorship program with us, and we are excited to welcome new contributors to Project Antrea.

We submitted the following projects for this iteration of the LFX Mentorship program:

• Compare Antrea BPF generation for PacketCapture to tcpdump / libpcap
  • https://mentorship.lfx.linuxfoundation.org/project/39be2843-94f8-4ac6-aa0a-3537631aca86
  • Issues: Compare Antrea BPF generation for PacketCapture to tcpdump / libpcap #7701

In order to help us find the right candidate, we have prepared a test task. It's a good opportunity for you to get familiar with the project proposals, and for us to ensure that you have some of the required skills for a successful mentorship.

The task is more advanced / involved / unsupervised than for previous mentorships for 2 reasons: we receive many applications and have trouble selecting the right candidate as a result, and the use of coding assistants makes simple coding tasks trivial.

We encourage the use of coding assistants, however:

1. Use them in a smart way.
2. Keep the source code small and readable.
3. Review everything that's generated and do not commit AI slop or unnecessary documentation.

Remember to apply at https://lfx.linuxfoundation.org/tools/mentorship/ in addition to completing the task.

Task details

The goal of this task is to produce a poor-man's version of the Antrea PacketCapture feature. You will implement a Kubernetes controller that runs as a DaemonSet and performs packet captures on demand.

High-level guidelines:

• Cluster Setup: Create a Kind cluster. You will need to disable the default CNI, as we will later deploy Antrea for networking. Refer to the Kind documentation for information. Deploy Antrea to the cluster; we recommend using Helm to install Antrea.
• Controller Implementation: Write a simple Go program which implements a K8s controller.
  • The program will run as a DaemonSet. It will watch all Pods running locally on the same Node. Ensure your DaemonSet has the necessary RBAC permissions to watch Pods.
  • It will run packet capture with tcpdump on demand when a certain annotation is added to the Pod.
  • The annotation will use format "tcpdump.antrea.io": "<N>".
  • N represents the max number of capture files. To implement this, your program will invoke tcpdump as follows: tcpdump -C 1M -W <N> -w /capture-<Pod name>.pcap.
  • Packet capture will stop as soon as the annotation is deleted. Pcap files will need to be deleted by your controller when the capture stops.
• Containerization: Define a Dockerfile for your program. Use ubuntu:24.04 as the base image. The container will need to include bash, tcpdump and your compiled Go program. Follow best practices when defining the Dockerfile (you can refer to the antrea-controller Dockerfile for an example). Load the image into your Kind cluster (e.g., using kind load docker-image).
• Verification:
  • Deploy a test Pod that generates network traffic (e.g., using ping or curl in a loop).
  • Annotate the test Pod with tcpdump.antrea.io: "5" (or another number).
  • Verify that the capture has started: exec into the capture Pod running on the same Node as your test Pod and check for the presence of pcap files (e.g., ls -l /capture-*).
  • Remove the annotation from the test Pod.
  • Verify that the capture has stopped and the pcap files have been deleted.

Deliverables:

Create a GitHub repository with the following:

• Go source code.
• Dockerfile and optionally a Makefile.
• Manifest for the capture DaemonSet.
• Manifest for the test Pod.
• Output of kubectl describe for the test Pod once it is running and annotated (save as pod-describe.txt).
• Output of kubectl get pods -A (save as pods.txt).
• Output of ls -l /capture-* from inside the capture Pod showing at least one non-empty pcap file (save as capture-files.txt).
• A copy of the pcap file extracted from the capture Pod (you can use kubectl cp).
• The human-readable text output of the pcap file, obtained by running tcpdump -r <file> on the extracted file (save as capture-output.txt).
• A short README.md

Organization of the repository is left to your discretion. Keep it simple, concise, and well-organized.

Submissions

Upon completing the task, reply to the thread with the following information:

Name: [Your name, as it appears in your LFX mentorship profile]
GitHub Repo: [Provide a link to your GitHub repository containing the completed task]

For any queries, please reply to the discussion thread or post in the #antrea channel in the K8s Slack workspace. Do not send emails or DMs to ask for assistance, use public channels only.

Deadlines

Task Deadline: Submissions must be completed by February 11, 11:00 AM PST..
LFX Application Deadline: LFX applicants must submit by February 10, 11:00 AM PST.

[antoninbas]

For submissions, please reply to this thread with the requested information

[Mou887]

Name : Moumita Dhar
Github Repo

[KhaledSayed04]

Name: Khaled Sayyed
GitHub Repo: https://github.com/KhaledSayed04/antrea-lfx-task

[sankalp-b1401]

For submissions, please reply to this thread with the requested information

Name: Sankalp Bansal
GitHub Repo: https://github.com/sankalp-b1401/antrea-test-task

[Shashwat-Patni]

Name : Shashwat Patni
Github Repo: https://github.com/Shashwat-Patni/Antrea_Test_Task_LFX_2026_Term_1

[codeafridi]

Name : Mohammed Afridi
github repo : https://github.com/codeafridi/Antrea-PacketCapture

[Maya-Mohamed]

Name: Maya Mohamed
GitHub Repo: https://github.com/Maya-Mohamed/antrea-packet-capture

[halfcrazy]

Why not generate expr from packetcapture crd and use the same way as tcpdump does to generate BPF code(introduce cgo and using libpcap)?
https://pkg.go.dev/github.com/gopacket/gopacket@v1.5.0/pcap#CompileBPFFilter

func CompileBPFFilter(linkType layers.LinkType, captureLength int, expr string) ([]BPFInstruction, error)

[antoninbas]

We didn't want to introduce a cgo dependency just for this, as it tends to increase build complexity. The CRD already defines the packet capture "expression" in a structured way and translating it to BPF is not that hard.