diff --git a/.forgejo/workflows/build.yaml b/.forgejo/workflows/build.yaml
deleted file mode 100644
index 32e5622..0000000
--- a/.forgejo/workflows/build.yaml
+++ /dev/null
@@ -1,21 +0,0 @@
-on:
-  push:
-    branches:
-      - main
-jobs:
-  build:
-    runs-on: [ nix ]
-    steps:
-    - uses: actions/checkout@v4
-    - name: Nix build
-      run: nix build --extra-experimental-features "flakes nix-command" .#docker-image
-    - name: Setup skopeo
-      run: curl -o /etc/containers/policy.json --create-dirs https://raw.githubusercontent.com/containers/skopeo/refs/heads/main/default-policy.json
-    - name: Push Image
-      run: |
-       skopeo copy --dest-password "$UPLOAD_TOKEN" --dest-username "$USERNAME" "docker-archive://$(realpath result)" "docker://$IMG_URL:${{ github.sha }}" && \
-       skopeo copy --dest-password "$UPLOAD_TOKEN" --dest-username "$USERNAME" "docker-archive://$(realpath result)" "docker://$IMG_URL"
-      env: 
-        USERNAME: tamipes
-        UPLOAD_TOKEN: ${{ secrets.UPLOAD_TOKEN }}
-        IMG_URL: git.tami.moe/tamipes/minecraft-ingress
diff --git a/kube/roles.yaml b/kube/roles.yaml
index 0c90cc6..09111bf 100644
--- a/kube/roles.yaml
+++ b/kube/roles.yaml
@@ -47,7 +47,7 @@ spec:
       serviceAccountName: minecraft-ingress
       containers:
       - name: minecraft-ingress
-        image: git.tami.moe/tamipes/minecraft-ingress:testing
+        image: git.tami.moe/tamipes/minecraft-ingress:latest
         env:
         - name: FILTER_CONN
           value: '(addr == "87.229.85.222") || (addr == "") || (addr == "ogmur.xyz") || (addr == "@mat:matdoes.dev (hi honeypots) ") || (addr == "@mat:matdoes.dev ") || (addr == "slowstack.tv")'
diff --git a/src/kube_cache.rs b/src/kube_cache.rs
index 9b9e671..c8be2e5 100644
--- a/src/kube_cache.rs
+++ b/src/kube_cache.rs
@@ -1,9 +1,6 @@
 use std::{collections::HashMap, fmt, sync::Arc, time::Duration};
 
-use k8s_openapi::{
-    api::{apps::v1::Deployment, core::v1::Service},
-    apimachinery::pkg::util::intstr::IntOrString,
-};
+use k8s_openapi::api::{apps::v1::Deployment, core::v1::Service};
 use kube::{
     api::{ListParams, ObjectList, Patch, PatchParams},
     runtime::reflector::Lookup,
@@ -28,17 +25,13 @@ use crate::{
 pub struct KubeCache {
     deployments: Api<Deployment>,
     services: Api<Service>,
-    in_cluster: bool,
 }
 impl KubeCache {
     /// This initializes the creation of a "kubernetes client"
     /// and if it is not possible returns a None.
-    pub async fn create() -> Option<KubeCache> {
-        let in_cluster = match std::env::var("KUBERNETES_SERVICE_HOST") {
-            Ok(x) => true,
-            Err(e) => false,
-        };
-        let client = Client::try_default().await.unwrap();
+    pub fn create() -> Option<KubeCache> {
+        let kubeconfig = kube::config::Kubeconfig::read().unwrap();
+        let client = Client::try_from(kubeconfig).unwrap();
 
         let deployments: Api<Deployment> = Api::default_namespaced(client.clone());
         let services: Api<Service> = Api::default_namespaced(client);
@@ -46,7 +39,6 @@ impl KubeCache {
         return Some(KubeCache {
             deployments,
             services,
-            in_cluster,
         });
     }
     async fn get_dep(&self, name: &str) -> Result<Deployment, kube::Error> {
@@ -72,17 +64,10 @@ impl KubeCache {
         Some(result.name()?.to_string())
     }
 
-    pub async fn query_srv(&self, addr: &str, port: &str) -> Option<Service> {
+    pub async fn query_srv_addr(&self, addr: &str, port: &str) -> Option<String> {
         let deploys = self.get_srvs().await;
-        let result = deploys.into_iter().find(|x| {
-            let in_cluster = match x.spec.as_ref().unwrap().type_.as_ref() {
-                Some(t) => t == "ClusterIP",
-                None => false,
-            };
-            let incorrect_type = in_cluster ^ self.in_cluster;
-            !incorrect_type && filter_label_value(&x, addr, port)
-        })?;
-        Some(result)
+        let result = deploys.iter().find(|x| filter_label_value(x, addr, port))?;
+        Some(result.name()?.to_string())
     }
 
     async fn set_dep_scale(&self, name: &str, num: i32) -> Result<Deployment, kube::Error> {
@@ -116,11 +101,11 @@ impl MinecraftAPI<Server> for McApi {
                 ))
             }
         };
-        let service = match self.cache.query_srv(&addr, &port).await {
+        let srv_name = match self.cache.query_srv_addr(&addr, &port).await {
             Some(x) => x,
             None => {
                 return Err(OpaqueError::create_with_kind(
-                    "Failed to find service by addr and port",
+                    "Failed to find service name by addr",
                     "SrvNameLookupFailed",
                 ))
             }
@@ -132,46 +117,20 @@ impl MinecraftAPI<Server> for McApi {
                 x.to_string()
             )
         })?;
+        let service = self.cache.get_srv(&srv_name).await.map_err(|x| {
+            format!(
+                "Failed to query cache for service with dep_name err:{}",
+                x.to_string()
+            )
+        })?;
         tracing::debug!("found kubernetes deployment & service");
 
-        let service_port_spec = service.clone().spec.unwrap().ports.unwrap();
-        let port = service_port_spec
-            .iter()
-            .find(|x| x.name.clone().unwrap() == "mc-router")
-            .ok_or(OpaqueError::create(
-                "Could not find \"mc-router\" nodePort for server",
-            ))?;
-        let port_string;
-        let inter_addr = match self.cache.in_cluster {
-            false => {
-                let node_port = port
-                    .node_port
-                    .map(|x| x.to_string())
-                    .ok_or(OpaqueError::create("Could not map nodePort to port string"))?;
-                port_string = node_port.clone();
-                format!("localhost:{}", node_port)
-            }
-            true => {
-                let target_port = port.port;
-                let a = format!(
-                    "{}.default.svc.cluster.local:{}",
-                    service
-                        .name()
-                        .ok_or("Could not get name of ClusterIP service")?,
-                    target_port
-                );
-                port_string = a.clone();
-                a
-            }
-        };
-        tracing::info!(inter_addr = inter_addr);
         return Ok(Server {
             dep: deployment,
             srv: service,
             server_addr: addr.to_string(),
-            server_port: port_string,
+            server_port: port.to_string(),
             cache: self.cache.clone(),
-            inter_addr: inter_addr,
         });
     }
 
@@ -250,9 +209,9 @@ impl MinecraftAPI<Server> for McApi {
 }
 
 impl McApi {
-    pub async fn create() -> Option<Self> {
+    pub fn create() -> Option<Self> {
         Some(Self {
-            cache: KubeCache::create().await?,
+            cache: KubeCache::create()?,
             map: Arc::new(tokio::sync::Mutex::new(HashMap::new())),
         })
     }
@@ -265,7 +224,6 @@ pub struct Server {
     server_addr: String,
     server_port: String,
     cache: KubeCache,
-    inter_addr: String,
 }
 impl fmt::Debug for Server {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -351,8 +309,8 @@ impl MinecraftServerHandle for Server {
         }
     }
 
-    fn get_internal_address(&self) -> &str {
-        self.inter_addr.as_str()
+    fn get_internal_address(&self) -> Option<String> {
+        Some(format!("localhost:{}", self.get_internal_port()?))
     }
 
     fn get_addr(&self) -> Option<String> {
@@ -401,6 +359,11 @@ impl MinecraftServerHandle for Server {
         }
     }
 
+    fn get_internal_port(&self) -> Option<String> {
+        let a = self.srv.clone().spec.unwrap().ports.unwrap();
+        let port = a.iter().find(|x| x.name.clone().unwrap() == "mc-router")?;
+        port.node_port.map(|x| x.to_string())
+    }
     fn get_port(&self) -> Option<String> {
         Some(self.server_port.clone())
     }
diff --git a/src/main.rs b/src/main.rs
index 044cbc9..80c5a3c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -39,7 +39,7 @@ async fn main() {
     let revision: &'static str = env!("COMMIT_HASH");
     tracing::info!(revision);
 
-    let api = kube_cache::McApi::create().await.unwrap();
+    let api = kube_cache::McApi::create().unwrap();
     tracing::info!("initialized kube api");
 
     let config: Config = Default::default();
diff --git a/src/mc_server.rs b/src/mc_server.rs
index 88e6e8b..03b6a9d 100644
--- a/src/mc_server.rs
+++ b/src/mc_server.rs
@@ -64,13 +64,16 @@ pub trait MinecraftServerHandle: Clone {
     async fn start(&self) -> Result<(), OpaqueError>;
     async fn stop(&self) -> Result<(), OpaqueError>;
     async fn query_status(&self) -> Result<ServerDeploymentStatus, OpaqueError>;
-    fn get_internal_address(&self) -> &str;
+    fn get_internal_address(&self) -> Option<String>;
+    fn get_internal_port(&self) -> Option<String>;
     fn get_addr(&self) -> Option<String>;
     fn get_port(&self) -> Option<String>;
     fn get_motd(&self) -> Option<String>;
 
     async fn query_server_connectable(&self) -> Result<TcpStream, OpaqueError> {
-        let address = self.get_internal_address();
+        let address = self
+            .get_internal_address()
+            .ok_or_else(|| "failed to get internal address from server")?;
         let server_stream = TcpStream::connect(address)
             .await
             .map_err(|_| "failed to connect to minecraft server")?;