<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Samarth Naphade on Medium]]></title>
        <description><![CDATA[Stories by Samarth Naphade on Medium]]></description>
        <link>https://medium.com/@samarthnaphade?source=rss-09146280cbaa------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*6QzhtEiROLXs2tGG</url>
            <title>Stories by Samarth Naphade on Medium</title>
            <link>https://medium.com/@samarthnaphade?source=rss-09146280cbaa------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 21:57:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@samarthnaphade/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Deploying Apache Airflow On Low Specs Machine (t2.micro): Achieving Efficiency on a Budget]]></title>
            <link>https://blog.devgenius.io/deploying-apache-airflow-on-low-specs-machine-t2-micro-achieving-efficiency-on-a-budget-10bf5d6f378e?source=rss-09146280cbaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/10bf5d6f378e</guid>
            <category><![CDATA[airflow]]></category>
            <category><![CDATA[etl-tool]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[buget-deployment]]></category>
            <category><![CDATA[airflow-installation]]></category>
            <dc:creator><![CDATA[Samarth Naphade]]></dc:creator>
            <pubDate>Mon, 24 Jun 2024 11:07:04 GMT</pubDate>
            <atom:updated>2024-06-27T18:06:24.578Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oe52i9Gz1jselj7fgoLEYg.jpeg" /></figure><p>Running Airflow using Helm or the official Docker Compose configuration typically requires substantial resources, with the Airflow website recommending at least 4GB of RAM. Commercial Apache Airflow solutions provided by GCP and AWS are also quite expensive; for example, GCP costs approximately $73 per month.</p><p>As I aimed to explore Airflow and run a few low-resource DAGs, I needed a more cost-effective solution. My goal was to make it work on a t2.micro instance, which falls under the GCP free tier.</p><p>Embarking on this journey, I discovered how to successfully deploy Airflow on the lowest spec machine, and I managed to run my required DAGs effectively.</p><p>For those who prefer to bypass the deployment process and jump straight into running Airflow, I have created a Docker image and uploaded it to Docker Hub (<a href="https://hub.docker.com/repository/docker/samarthnaphade/airflow_one_container_image/general">samarthnaphade/airflow_one_container_image</a>). Simply use the Docker Compose file available in the <a href="https://github.com/Samarth-2561/airflow_one_container/blob/main/airflow_in_one_container/docker-compose.yml">GitHub repository</a> to get started.</p><h3>Prerequisites:</h3><ol><li>Install Docker and Docker Compose (if using linux use this <a href="https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-20-04">link</a>).</li></ol><h3>Steps for running the airflow:</h3><h4>1. Place the Docker Compose File in the Machine.</h4><ul><li>Start by creating a directory called airflow in your home directory on the machine.</li><li>Move the Docker Compose file into this newly created airflow directory.</li></ul><pre>cd ~<br>mkdir airflow<br>cd airflow<br>wget https://raw.githubusercontent.com/Samarth-2561/airflow_one_container/main/airflow_in_one_container/Dockerfile</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CHmGgmdu-mDvThF5JzUPzQ.png" /><figcaption>creating directories and getting the docker-compose.yaml</figcaption></figure><h4>2. Create the required folders</h4><ul><li>Inside the airflow directory, create three folders named dags, logs, and plugins.</li></ul><pre>mkdir dags plugins logs</pre><h4>3. Place the Dags Code in the dags folder</h4><ul><li>Copy your DAG code into the dags folder to ensure Airflow can access and execute your workflows.</li></ul><pre>cp /path/to/your_dag.py ~/airflow/dags/</pre><h4>4. Start the Airflow Service</h4><p>Running the following command for starting the airflow service.</p><pre>docker compose up</pre><p>if you want to run this in background add ‘-D’ in the end.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aGikiJ81SqetZvcqIUh2Eg.png" /><figcaption>Logs of Docker Compose UP</figcaption></figure><p>Once the initialization is done, you should be some message in logs like</p><pre>airflow  | [2024-06-24 09:15:41 +0000] [16] [INFO] Listening at: http://0.0.0.0:8080 (16)<br>airflow  | [2024-06-24 09:15:41 +0000] [16] [INFO] Using worker: sync<br>airflow  | [2024-06-24 09:15:41 +0000] [31] [INFO] Booting worker with pid: 31<br>airflow  | [2024-06-24 09:15:41 +0000] [32] [INFO] Booting worker with pid: 32<br>airflow  | [2024-06-24 09:15:41 +0000] [33] [INFO] Booting worker with pid: 33<br>airflow  | [2024-06-24 09:15:41 +0000] [34] [INFO] Booting worker with pid: 34</pre><p>Voilà! Airflow should now be running and accessible on port 8080 of your machine. If you’re using a VM with an external IP, you can access the Airflow web interface at:</p><pre>http://&lt;external-ip&gt;:8080/login/</pre><p>Use the default credentials:</p><ul><li><strong>Username</strong>: admin</li><li><strong>Password</strong>: admin</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BO2Zgg04wPGsYhe0Zuoqcw.png" /><figcaption>Airflow UI</figcaption></figure><p>By following these steps, you can efficiently run Apache Airflow on a low-spec t2.micro instance, making it a cost-effective solution for exploring Airflow and running lightweight DAGs.</p><h3>Steps for Including Custom Python Library in Airflow:</h3><p>Integrating custom Python libraries into your Airflow setup can enhance its functionality and tailor it to your specific needs. Follow these steps to seamlessly include your custom dependencies in Airflow:</p><p><strong>Step 1: Clone the GitHub Project:<br></strong>Start by cloning the repository that contains your Airflow setup. This allows you to make modifications and add custom dependencies.</p><p><strong>Step 2: Update </strong><strong>requirements.txt</strong><br>Add the required dependencies to the requirements.txt file. This ensures that any additional Python libraries your DAGs need are installed.</p><p><strong>Step 3: Modify Docker Configuration</strong><br>To include your custom dependencies, you need to build a new Docker image. First, comment out the existing image line:</p><pre># image: samarthnaphade/airflow_one_container_image:v3</pre><p>Then, uncomment the build line:</p><pre>build: .</pre><p><strong>Step 4: Build the Custom Docker Image</strong><br>Build the Docker image with your custom dependencies using the following command:</p><pre>docker build . --tag airflow_extended:v1</pre><p>This command creates a new Docker image tagged airflow_extended:v1 that includes all the libraries specified in requirements.txt.</p><p><strong>Step 5: Update the Docker Compose File</strong><br>In your docker-compose.yml file, replace the image value with your newly built image:</p><pre>image: airflow_extended:v1</pre><p>And comment out the build line:</p><pre># build: .</pre><p><strong>Step 6: Launch Airflow</strong><br>Run the Airflow service using Docker Compose:</p><pre>docker compose up</pre><p>This command starts your Airflow instance with the custom Docker image, allowing you to use the libraries specified in requirements.txt within your DAGs.</p><p>By following these steps, you’ll have a tailored Airflow environment with the ability to leverage custom Python libraries in your workflows. This approach ensures that your DAGs are equipped with all the necessary tools to perform efficiently and effectively.</p><h3>Explanation:</h3><blockquote>docker-compose.yaml</blockquote><pre>name: airflow<br><br>services:<br>  airflow:<br>    platform: linux/amd64<br>    image: samarthnaphade/airflow_one_container_image:v3<br>    # In order to add custom dependencies or upgrade provider packages you can use your extended image.<br>    # and uncomment the &quot;build&quot; line below, add the python dependency in the requirements.txt, Then run `docker-compose build` to build the images.<br>    # after creating the build update the image tab.<br>    # build: .<br>    environment:<br>      AIRFLOW__CORE__LOAD_EXAMPLES: &quot;false&quot;<br>      AIRFLOW__API__AUTH_BACKENDS: &quot;airflow.api.auth.backend.basic_auth,airflow.api.auth.backend.session&quot;<br>    container_name: airflow<br>    restart: always<br>    ports:<br>      - &quot;8080:8080&quot;<br>    volumes:<br>      - type: bind<br>        source: ./dags<br>        target: /root/airflow/dags<br>      - type: bind<br>        source: ./logs<br>        target: /root/airflow/logs<br>      - type: bind<br>        source: ./plugins<br>        target: /root/airflow/plugins</pre><p>The platform is set to linux/amd64, which specifies the platform on which the service will run (This is need to done, as I have ARM Laptop causing issue while running images on NON ARM system). <br>The image field specifies the Docker image to use for the Airflow service, which is samarthnaphade/airflow_one_container_image with the tag v3.</p><p>The build line is commented out. If you need to extend the image with custom dependencies or upgrade provider packages, you can create a requirements.txt file, uncomment the build line, and use docker-compose build to build the image.</p><p>The environment section contains configuration settings for the Airflow instance:</p><ul><li>AIRFLOW__CORE__LOAD_EXAMPLES is set to false, configuring Airflow not to load example DAGs.</li><li>AIRFLOW__API__AUTH_BACKENDS is set to airflow.api.auth.backend.basic_auth,airflow.api.auth.backend.session, which specifies the authentication backends to use for the Airflow API. This includes basic authentication and session-based authentication.</li></ul><p>The container_name is set to airflow, which names the container airflow. The restart policy is set to always, which ensures the container always restarts if it stops or crashes.</p><p>The ports section maps port 8080 on the host machine to port 8080 in the container, allowing access to the Airflow web interface.</p><p>The volumes section mounts directories from the host machine into the container, which is useful for persisting data and configuration files:</p><ul><li>The ./dags directory from the host is mounted to /root/airflow/dags in the container, where DAG files are stored.</li><li>The ./logs directory from the host is mounted to /root/airflow/logs in the container, where log files are stored.</li><li>The ./plugins directory from the host is mounted to /root/airflow/plugins in the container, where custom plugins are stored.</li></ul><blockquote>Dockerfile</blockquote><pre>FROM python:3.12.3-slim<br><br>RUN apt update<br><br>RUN apt install gcc -y<br><br>RUN apt install python3-dev -y<br><br>RUN python3 -m pip install apache-airflow<br><br>COPY setup.sh .<br><br>COPY requirements.txt /requirements.txt<br><br>RUN pip install --no-cache-dir --user -r /requirements.txt<br><br>RUN chmod +x setup.sh<br><br>RUN mkdir -p /root/airflow/dags<br><br>RUN mkdir -p /root/airflow/plugins<br><br>CMD [ &quot;bash&quot;, &quot;setup.sh&quot;]<br><br>EXPOSE 8080</pre><p>This Dockerfile sets up an environment for Apache Airflow in a Docker container using python:3.12.3-slim as the base image. It starts by updating the package lists and installing gcc and python3-dev, which are necessary for compiling Python packages with C extensions. Apache Airflow is then installed via pip.</p><p>The setup.sh script and requirements.txt are copied into the container. The Python dependencies listed in requirements.txt are installed with pip, avoiding cache and installing in the user directory. The script is made executable with chmod +x setup.sh.</p><p>Directories for Airflow DAGs and plugins are created at /root/airflow/dags and /root/airflow/plugins. The container’s default command runs setup.sh using Bash, initializing and starting Airflow services. Finally, port 8080 is exposed for the Airflow web server. This setup ensures a ready-to-use environment for Apache Airflow within the Docker container.</p><blockquote>setup.sh</blockquote><pre>#!/bin/bash<br>echo Intializing the Airflow Database;<br>airflow db init;<br>echo Creating User Account;<br>airflow users create --role &quot;Admin&quot; --username &quot;admin&quot; --password &quot;admin&quot; --firstname &quot;admin&quot; --lastname &quot;admin&quot; --email &quot;admin&quot;;<br>echo Starting the Airflow Scheduler;<br>nohup airflow scheduler &gt;&gt; ~/airflow/logs/scheduler.logs &amp;<br>echo Starting the Airflow Webserver;<br>airflow webserver</pre><p>This shell script sets up and starts Apache Airflow services.<br>First, it initializes the Airflow database with the command airflow db init, ensuring the database is ready for use. It then creates an administrative user account using the airflow users create command, setting the role, username, password, and other user details to &quot;admin&quot;.</p><p>Next, the script starts the Airflow scheduler in the background, redirecting its output to a log file located at ~/airflow/logs/scheduler.logs using the nohup command. This ensures that the scheduler runs continuously, even if the terminal is closed.</p><p>Finally, the script starts the Airflow webserver with airflow webserver, making the Airflow user interface accessible. This setup sequence prepares and starts the necessary components for Apache Airflow to function properly.</p><p>Github Repo Link: <a href="https://github.com/Samarth-2561/airflow_one_container/tree/main">https://github.com/Samarth-2561/airflow_one_container/tree/main</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10bf5d6f378e" width="1" height="1" alt=""><hr><p><a href="https://blog.devgenius.io/deploying-apache-airflow-on-low-specs-machine-t2-micro-achieving-efficiency-on-a-budget-10bf5d6f378e">Deploying Apache Airflow On Low Specs Machine (t2.micro): Achieving Efficiency on a Budget</a> was originally published in <a href="https://blog.devgenius.io/">Dev Genius</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying NFS Server on Kubernetes (GKE)]]></title>
            <link>https://medium.com/@samarthnaphade/deploying-nfs-server-on-kubernetes-gke-b7d82c83c3c3?source=rss-09146280cbaa------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7d82c83c3c3</guid>
            <category><![CDATA[nfs-server]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[gke]]></category>
            <category><![CDATA[persistent-storage]]></category>
            <category><![CDATA[kubernetes-engine]]></category>
            <dc:creator><![CDATA[Samarth Naphade]]></dc:creator>
            <pubDate>Fri, 14 Jun 2024 14:22:24 GMT</pubDate>
            <atom:updated>2024-06-14T14:23:41.873Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*14I2nU-heFznbwwNyDzYRA.png" /></figure><p>To set up an NFS server on GKE using a GCE Persistent Disk for its storage, you’ll need to create a PersistentVolume (PV) and PersistentVolumeClaim (PVC) for the GCE Persistent Disk, and then use this PVC in your NFS server deployment. Here are the updated YAML files to achieve this.</p><h3>Step 1: Create GCE Persistent Disk</h3><p>First, create the GCE Persistent Disk using the gcloud command-line tool:</p><pre>gcloud compute disks create --size=10Gi --zone=asia-south1-a persistent-storage-gke</pre><p>Replace my-nfs-disk with the desired name of your disk and adjust the size and zone as needed.</p><h3>Step 2: Define the PersistentVolume (PV) and PersistentVolumeClaim (PVC) for Accessing the GCP Persistent Disk</h3><h3>PersistentVolume (PV) And PersistentVolumeClaim (PVC)</h3><p>filename: 01-pv-pvc-persistent-disk.yaml</p><pre>apiVersion: v1<br>kind: PersistentVolume<br>metadata:<br>  name: my-nfs-pv<br>spec:<br>  capacity:<br>    storage: 10Gi<br>  accessModes:<br>    - ReadWriteOnce<br>  persistentVolumeReclaimPolicy: Retain<br>  gcePersistentDisk:<br>    pdName: persistent-storage-gke<br>    fsType: ext4<br><br>---<br><br>apiVersion: v1<br>kind: PersistentVolumeClaim<br>metadata:<br>  name: my-nfs-pvc<br>spec:<br>  accessModes:<br>    - ReadWriteOnce<br>  resources:<br>    requests:<br>      storage: 10Gi</pre><h3>Step 3: Deploy the NFS Server Using the PVC</h3><h3>NFS Server Deployment</h3><p>filename: 02-deploy-nfs-service.yml</p><pre>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: nfs-server<br>spec:<br>  replicas: 1<br>  selector:<br>    matchLabels:<br>      app: nfs-server<br>  template:<br>    metadata:<br>      labels:<br>        app: nfs-server<br>    spec:<br>      containers:<br>      - name: nfs-server<br>        image: k8s.gcr.io/volume-nfs:0.8<br>        ports:<br>        - name: nfs<br>          containerPort: 2049<br>        - name: mountd<br>          containerPort: 20048<br>        - name: rpcbind<br>          containerPort: 111<br>        securityContext:<br>          privileged: true<br>        volumeMounts:<br>        - name: nfs-storage<br>          mountPath: /exports<br>      volumes:<br>      - name: nfs-storage<br>        persistentVolumeClaim:<br>          claimName: my-nfs-pvc</pre><h3>NFS Server Service</h3><p>filename: 03-svc-nfs.yml</p><pre>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: nfs-server<br>spec:<br>  selector:<br>    app: nfs-server<br>  ports:<br>  - name: nfs<br>    port: 2049<br>  - name: mountd<br>    port: 20048<br>  - name: rpcbind<br>    port: 111</pre><h3>Step 5: Define the PersistentVolume (PV) and PersistentVolumeClaim (PVC) for NFS Client</h3><p>filename: 04-pv-and-pvc-nfs.yml</p><pre>apiVersion: v1<br>kind: PersistentVolume<br>metadata:<br>  name: nfs-client<br>spec:<br>  capacity:<br>    storage: 10Gi<br>  accessModes:<br>    - ReadWriteMany<br>    - ReadOnlyMany<br>  nfs:<br>    # FIXED: Use internal DNS name<br>    server: nfs-server.default.svc.cluster.local<br>    path: &quot;/&quot;<br><br>---<br>kind: PersistentVolumeClaim<br>apiVersion: v1<br>metadata:<br>  name: nfs-client-pvc<br>spec:<br>  accessModes:<br>    - ReadWriteMany<br>  storageClassName: &quot;&quot;<br>  resources:<br>    requests:<br>      storage: 1Gi</pre><h3>Step 6: Define the Application Deployment</h3><h3>NFS Client</h3><p>filename: 05-nfs-client.yaml</p><pre>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: my-deployment<br>spec:<br>  replicas: 3<br>  selector:<br>    matchLabels:<br>      app: my-app<br>  template:<br>    metadata:<br>      labels:<br>        app: my-app<br>    spec:<br>      containers:<br>      - name: nginx<br>        image: nginx:latest<br>        volumeMounts:<br>        - mountPath: &quot;/mnt/my-persistent-storage&quot;<br>          name: my-storage<br>      volumes:<br>      - name: my-storage<br>        nfs:<br>          server: nfs-server.default.svc.cluster.local<br>          path: /</pre><h3>Apply the configurations</h3><p>Run the following commands to apply the configurations:</p><pre>kubectl apply -f 01-pv-pvc-persistent-disk.yaml<br>kubectl apply -f 02-deploy-nfs-service.yml<br>kubectl apply -f 03-svc-nfs.yml<br>kubectl apply -f 04-pv-and-pvc-nfs.yml<br>kubectl apply -f 05-nfs-client.yaml</pre><p>Explanation:</p><ol><li><strong>PersistentVolume (PV)</strong>: Defines a PersistentVolume that uses a GCE Persistent Disk.</li><li><strong>PersistentVolumeClaim (PVC)</strong>: Requests the PersistentVolume for the NFS server.</li><li><strong>NFS Server Deployment</strong>: Deploys the NFS server using the PVC for storage.</li><li><strong>NFS Server Service</strong>: Creates a service for the NFS server.</li><li><strong>Application Deployment</strong>: Deploys an application that uses the NFS storage provided by the NFS server.</li></ol><p>This setup ensures that your NFS server uses the GCE Persistent Disk for its storage, providing faster and more reliable persistent storage for your application.</p><h3>Validating if the NFS service is setup correctly</h3><p>For Checking if the NFS setup is working correctly, we can use ‘exec’ commands, to open a bash terminal in the pods and check the files.</p><h3>1. Get the Pods running in GKE:</h3><p>Use the below command for getting the pods.</p><pre>kubectl get pods</pre><p>You should get 4 pods running — 3 my-deployment-xxxxxxxxx-xxxx pods and 1 nfs-server-xxxxxxxxxxx-xxxx pods.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*LyPmircyPTeLUHa-5EIjdg.png" /></figure><p>Select any 2 pods from my deployment pods.<br>For demo I will select pods named — my-deployment-6c46c5c96f-54hsz and my-deployment-6c46c5c96f-drq6l.</p><h3>2. Open Bash Terminal in Pods:</h3><p>For opening Bash terminal in the pods, we can use the command:</p><pre>kubectl exec -it my-deployment-xxxxxxxxx-xxxx -- bash</pre><p>Use this command to open bash terminal in the selected pods.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EfgNPDMwp_eXkAtE7HkO6A.png" /><figcaption>Bash terminal in pods</figcaption></figure><h3>3. Verifying NFS Shared Storage Across Pods:</h3><p>To verify that the NFS shared storage is working correctly, follow these steps from two different pods. The NFS server location is mounted at /mnt/my-persistent-storage.</p><h4>Pods 1:</h4><ol><li>Navigate to the mounted folder:</li></ol><pre>cd /mnt/my-persistent-storage</pre><p>2. Create a test file in the shared folder:</p><pre>echo &quot;Test File&quot; &gt; test_file.txt</pre><p>3. List the files to verify the creation of test_file.txt:</p><pre>ls</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QX81dq2exOJ-Ui68xp3XWA.png" /><figcaption>Pod 1 output log</figcaption></figure><h4>Pods 2:</h4><ol><li>Navigate to the mounted folder:</li></ol><pre>cd /mnt/my-persistent-storage</pre><p>2. List the files to verify that test_file.txt is accessible:</p><pre>ls</pre><p>3. Check the file content of test_file.txt.</p><pre>echo test_file.txt</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AhZl4BHR2tk_3m-MQsdOzg.png" /><figcaption>Pod 2 output log</figcaption></figure><p>If test_file.txt is listed in the output for Pod 2, the NFS shared storage is successfully mounted and accessible across pods.</p><h3>Clean Up Activity</h3><p>To delete the resources created for the NFS Server, execute the following commands:</p><ol><li>Delete the deployment for your application:</li></ol><pre><br>kubectl delete deployment my-deployment</pre><p>2. Delete the deployment for the NFS server:</p><pre>kubectl delete deployment nfs-server</pre><p>3. Delete the persistent volume claims (PVC):</p><pre>kubectl delete pvc nfs-client<br>kubectl delete pvc nfs-client-pvc</pre><p>4. Delete the persistent volumes (PV):</p><pre>kubectl delete pv nfs-client<br>kubectl delete pv my-nfs-pv</pre><p>By running these commands, you will remove all the resources associated with your NFS Server setup.</p><p>Github Project Link:<br><a href="https://github.com/Samarth-2561/nfs_service_kubernetes">https://github.com/Samarth-2561/nfs_service_kubernetes</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7d82c83c3c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>