mirror of
https://github.com/sadoyan/aralez.git
synced 2026-10-23 06:01:35 +08:00
Full rewrite of Kubernetes integration.
This commit is contained in:
Ara Sadoyan
@@ -8,6 +8,7 @@ pub mod healthcheck;
|
||||
pub mod httpclient;
|
||||
pub mod jwt;
|
||||
pub mod kuberconsul;
|
||||
pub mod kubewatcher;
|
||||
pub mod lazylock;
|
||||
pub mod metrics;
|
||||
pub mod parceyaml;
|
||||
|
||||
@@ -7,7 +7,7 @@ use std::sync::atomic::AtomicUsize;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tokio::net::TcpStream;
|
||||
use tokio::time::interval;
|
||||
use tokio::time::{interval, timeout};
|
||||
use tokio_native_tls::native_tls::TlsConnector;
|
||||
|
||||
pub async fn hc2(upslist: Arc<UpstreamsDashMap>, fullist: Arc<UpstreamsDashMap>, idlist: Arc<UpstreamsIdMap>, params: (&str, u64)) {
|
||||
@@ -86,12 +86,12 @@ async fn build_upstreams(fullist: &UpstreamsDashMap, method: &str) -> UpstreamsD
|
||||
|
||||
async fn detect_tls(ip: &str, port: &u16, sni: &str) -> bool {
|
||||
let addr = format!("{ip}:{port}");
|
||||
|
||||
let stream = match TcpStream::connect(&addr).await {
|
||||
Ok(s) => s,
|
||||
let timeout_duration = Duration::from_secs(2); // THINK !!!
|
||||
let stream = match timeout(timeout_duration, TcpStream::connect(&addr)).await {
|
||||
Ok(Ok(s)) => s,
|
||||
Ok(Err(_)) => return false,
|
||||
Err(_) => return false,
|
||||
};
|
||||
|
||||
let connector = tokio_native_tls::TlsConnector::from(
|
||||
TlsConnector::builder()
|
||||
.danger_accept_invalid_certs(true)
|
||||
|
||||
+129
-79
@@ -1,9 +1,11 @@
|
||||
use crate::utils::httpclient;
|
||||
use crate::utils::kubewatcher::{start_ingress_watcher_with_config, AralezRouteUpdate};
|
||||
use crate::utils::parceyaml::build_headers;
|
||||
use crate::utils::structs::{Configuration, GlobalServiceMapping, InnerMap, UpstreamsDashMap};
|
||||
use crate::utils::tools::{clone_dashmap_into, compare_dashmaps, print_upstreams};
|
||||
use async_trait::async_trait;
|
||||
use dashmap::DashMap;
|
||||
use log::error;
|
||||
use pingora::prelude::sleep;
|
||||
use rand::RngExt;
|
||||
use serde::Deserialize;
|
||||
@@ -16,12 +18,16 @@ use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tokio::fs::File;
|
||||
use tokio::io::AsyncReadExt;
|
||||
|
||||
use rustls::crypto::ring::default_provider;
|
||||
use rustls::crypto::CryptoProvider;
|
||||
use tokio::sync::mpsc::Sender;
|
||||
|
||||
#[derive(Debug, serde::Deserialize)]
|
||||
pub struct KubeEndpoints {
|
||||
pub subsets: Option<Vec<KubeSubset>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, serde::Deserialize)]
|
||||
pub struct KubeSubset {
|
||||
pub addresses: Option<Vec<KubeAddress>>,
|
||||
@@ -51,31 +57,27 @@ pub struct ConsulTaggedAddress {
|
||||
#[serde(rename = "Port")]
|
||||
pub port: u16,
|
||||
}
|
||||
|
||||
#[allow(clippy::type_complexity)]
|
||||
pub fn list_to_upstreams(lt: Option<DashMap<Arc<str>, (Vec<Arc<InnerMap>>, AtomicUsize)>>, upstreams: &UpstreamsDashMap, i: &GlobalServiceMapping) {
|
||||
if let Some(list) = lt {
|
||||
match upstreams.get(&*i.hostname.clone()) {
|
||||
let key: Arc<str> = Arc::from(i.hostname.as_str());
|
||||
match upstreams.get(&key) {
|
||||
Some(upstr) => {
|
||||
for (k, v) in list {
|
||||
upstr.value().insert(k.to_owned(), v);
|
||||
upstr.value().insert(k, v);
|
||||
}
|
||||
}
|
||||
None => {
|
||||
upstreams.insert(Arc::from(i.hostname.clone()), list);
|
||||
upstreams.insert(key, list);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
pub fn match_path(conf: &GlobalServiceMapping, upstreams: &DashMap<Arc<str>, (Vec<Arc<InnerMap>>, AtomicUsize)>, values: Vec<Arc<InnerMap>>) {
|
||||
match conf.path {
|
||||
Some(ref p) => {
|
||||
upstreams.insert(Arc::from(p.clone()), (values, AtomicUsize::new(0)));
|
||||
}
|
||||
None => {
|
||||
upstreams.insert(Arc::from("/"), (values, AtomicUsize::new(0)));
|
||||
}
|
||||
}
|
||||
let path = conf.path.as_deref().unwrap_or("/");
|
||||
upstreams.insert(Arc::from(path), (values, AtomicUsize::new(0)));
|
||||
}
|
||||
|
||||
async fn read_token(path: &str) -> String {
|
||||
@@ -84,6 +86,7 @@ async fn read_token(path: &str) -> String {
|
||||
file.read_to_string(&mut contents).await.unwrap();
|
||||
contents.trim().to_string()
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
pub trait ServiceDiscovery {
|
||||
async fn fetch_upstreams(&self, config: Arc<Configuration>, toreturn: Sender<Configuration>);
|
||||
@@ -95,55 +98,104 @@ pub struct ConsulDiscovery;
|
||||
#[async_trait]
|
||||
impl ServiceDiscovery for KubernetesDiscovery {
|
||||
async fn fetch_upstreams(&self, config: Arc<Configuration>, toreturn: Sender<Configuration>) {
|
||||
let prev_upstreams = UpstreamsDashMap::new();
|
||||
|
||||
if let Some(kuber) = config.kubernetes.clone() {
|
||||
let servers = kuber.servers.unwrap_or(vec![format!(
|
||||
"{}:{}",
|
||||
env::var("KUBERNETES_SERVICE_HOST").unwrap_or("0.0.0.0".to_string()),
|
||||
env::var("KUBERNETES_SERVICE_PORT_HTTPS").unwrap_or("0".to_string())
|
||||
)]);
|
||||
let servers = kuber.servers.unwrap_or_else(|| {
|
||||
vec![format!(
|
||||
"{}:{}",
|
||||
env::var("KUBERNETES_SERVICE_HOST").unwrap_or_else(|_| "0.0.0.0".to_string()),
|
||||
env::var("KUBERNETES_SERVICE_PORT_HTTPS").unwrap_or_else(|_| "0".to_string())
|
||||
)]
|
||||
});
|
||||
|
||||
let end = servers.len().saturating_sub(1);
|
||||
let num = if end > 0 { rand::rng().random_range(0..end) } else { 0 };
|
||||
let server = servers.get(num).unwrap().to_string();
|
||||
let path = kuber.tokenpath.unwrap_or("/var/run/secrets/kubernetes.io/serviceaccount/token".to_string());
|
||||
let path = kuber.tokenpath.unwrap_or_else(|| "/var/run/secrets/kubernetes.io/serviceaccount/token".to_string());
|
||||
let namespace = get_current_namespace().unwrap_or_else(|| "default".to_string());
|
||||
let token = read_token(path.as_str()).await;
|
||||
loop {
|
||||
let upstreams = UpstreamsDashMap::new();
|
||||
if let Some(kuber) = config.kubernetes.clone() {
|
||||
if let Some(svc) = kuber.services {
|
||||
for service in svc {
|
||||
let header_list: DashMap<Arc<str>, Vec<(String, Arc<str>)>> = DashMap::new();
|
||||
let mut hl = Vec::new();
|
||||
build_headers(&service.client_headers, config.as_ref(), &mut hl);
|
||||
if !hl.is_empty() {
|
||||
match service.path.clone() {
|
||||
Some(path) => {
|
||||
header_list.insert(Arc::from(path.as_str()), hl);
|
||||
}
|
||||
None => {
|
||||
header_list.insert(Arc::from("/"), hl);
|
||||
}
|
||||
}
|
||||
|
||||
// header_list.insert(Arc::from(path.as_str()), hl);
|
||||
// header_list.insert(Arc::from(i.path).unwrap_or(Arc::from("/")).as_str(), hl);
|
||||
config.client_headers.insert(Arc::from(service.hostname.clone()), header_list);
|
||||
}
|
||||
let url = format!("https://{}/api/v1/namespaces/{}/endpoints/{}", server, namespace, service.hostname);
|
||||
// let url = format!("https://{}/api/v1/namespaces/{}/endpoints?labelSelector=app", server, namespace);
|
||||
let list = httpclient::for_kuber(&url, &token, &service).await;
|
||||
// println!("{:?}", list);
|
||||
list_to_upstreams(list, &upstreams, &service);
|
||||
}
|
||||
}
|
||||
if let Some(lt) = clone_compare(&upstreams, &prev_upstreams, &config).await {
|
||||
toreturn.send(lt).await.unwrap();
|
||||
}
|
||||
if CryptoProvider::get_default().is_none() {
|
||||
default_provider().install_default().expect("Failed to install rustls crypto provider");
|
||||
}
|
||||
|
||||
let (tx, mut rx) = tokio::sync::mpsc::channel::<AralezRouteUpdate>(100);
|
||||
let srv = server.clone();
|
||||
let tok = token.clone();
|
||||
tokio::spawn(async move {
|
||||
if let Err(e) = start_ingress_watcher_with_config(srv.as_str(), tok.as_str(), tx, "aralez").await {
|
||||
error!("Fatal watcher error: {:?}", e);
|
||||
}
|
||||
});
|
||||
|
||||
let upstreams = UpstreamsDashMap::new();
|
||||
|
||||
while let Some(update) = rx.recv().await {
|
||||
let host_key: Arc<str> = Arc::from(update.host.as_str());
|
||||
|
||||
if update.is_deleted {
|
||||
upstreams.remove(&host_key);
|
||||
config.client_headers.remove(&host_key);
|
||||
} else {
|
||||
let service = GlobalServiceMapping {
|
||||
upstream: update.service_name.clone(),
|
||||
hostname: update.host.clone(),
|
||||
path: Some(update.path.clone()),
|
||||
to_https: None,
|
||||
sticky_sessions: update.sticky_sessions,
|
||||
rate_limit: update.rate_limit,
|
||||
x4xx_limit: update.x4xx_limit,
|
||||
client_headers: None,
|
||||
server_headers: None,
|
||||
};
|
||||
|
||||
let cheader_list: DashMap<Arc<str>, Vec<(String, Arc<str>)>> = DashMap::new();
|
||||
let sheader_list: DashMap<Arc<str>, Vec<(String, Arc<str>)>> = DashMap::new();
|
||||
|
||||
let mut client_headers_list = Vec::new();
|
||||
let mut server_headers_list = Vec::new();
|
||||
|
||||
let mut chl: Option<Vec<String>> = None;
|
||||
let mut shl: Option<Vec<String>> = None;
|
||||
|
||||
if let Some(hdr) = service.client_headers.as_ref() {
|
||||
chl.get_or_insert_with(Vec::new).extend(hdr.iter().cloned());
|
||||
}
|
||||
if let Some(hdr) = service.server_headers.as_ref() {
|
||||
shl.get_or_insert_with(Vec::new).extend(hdr.iter().cloned());
|
||||
}
|
||||
|
||||
if let Some(ch) = update.client_headers {
|
||||
chl.get_or_insert_with(Vec::new).extend(ch);
|
||||
}
|
||||
if let Some(hdr) = update.server_headers.as_ref() {
|
||||
shl.get_or_insert_with(Vec::new).extend(hdr.iter().cloned());
|
||||
}
|
||||
|
||||
build_headers(&chl, config.as_ref(), &mut client_headers_list);
|
||||
if !client_headers_list.is_empty() {
|
||||
let path_key = service.path.as_deref().unwrap_or("/");
|
||||
cheader_list.insert(Arc::from(path_key), client_headers_list);
|
||||
config.client_headers.insert(host_key.clone(), cheader_list);
|
||||
}
|
||||
|
||||
build_headers(&shl, config.as_ref(), &mut server_headers_list);
|
||||
if !server_headers_list.is_empty() {
|
||||
let path_key = service.path.as_deref().unwrap_or("/");
|
||||
sheader_list.insert(Arc::from(path_key), server_headers_list);
|
||||
config.server_headers.insert(host_key.clone(), sheader_list);
|
||||
}
|
||||
let url = format!("https://{}/api/v1/namespaces/{}/endpoints/{}", server, namespace, update.service_name);
|
||||
let list = httpclient::for_kuber(&url, &token, &service).await;
|
||||
|
||||
if list.is_none() {
|
||||
error!("Endpoint URL: {} returned empty/invalid response", url);
|
||||
}
|
||||
|
||||
list_to_upstreams(list, &upstreams, &service);
|
||||
}
|
||||
if let Some(lt) = clone_compare(&upstreams, &config).await {
|
||||
let _ = toreturn.send(lt).await;
|
||||
}
|
||||
sleep(Duration::from_secs(5)).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -156,61 +208,58 @@ fn get_current_namespace() -> Option<String> {
|
||||
return Some(contents.trim().to_string());
|
||||
}
|
||||
}
|
||||
std::env::var("POD_NAMESPACE").ok()
|
||||
env::var("POD_NAMESPACE").ok()
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl ServiceDiscovery for ConsulDiscovery {
|
||||
async fn fetch_upstreams(&self, config: Arc<Configuration>, toreturn: Sender<Configuration>) {
|
||||
let prev_upstreams = UpstreamsDashMap::new();
|
||||
loop {
|
||||
let upstreams = UpstreamsDashMap::new();
|
||||
|
||||
if let Some(consul) = config.consul.clone() {
|
||||
let servers = consul.servers.unwrap_or(vec![format!(
|
||||
"{}:{}",
|
||||
env::var("CONSUL_SERVICE_HOST").unwrap_or("0.0.0.0".to_string()),
|
||||
env::var("CONSUL_SERVICE_PORT").unwrap_or("0".to_string())
|
||||
)]);
|
||||
let servers = consul.servers.unwrap_or_else(|| {
|
||||
vec![format!(
|
||||
"{}:{}",
|
||||
env::var("CONSUL_SERVICE_HOST").unwrap_or_else(|_| "0.0.0.0".to_string()),
|
||||
env::var("CONSUL_SERVICE_PORT").unwrap_or_else(|_| "0".to_string())
|
||||
)]
|
||||
});
|
||||
let end = servers.len().saturating_sub(1);
|
||||
let num = if end > 0 { rand::rng().random_range(0..end) } else { 0 };
|
||||
let consul_data = servers.get(num).unwrap().to_string();
|
||||
let ss = consul_data + "/v1/catalog/service/";
|
||||
let ss = format!("{}/v1/catalog/service/", consul_data);
|
||||
|
||||
if let Some(svc) = consul.services {
|
||||
for i in svc {
|
||||
for i in &svc {
|
||||
let header_list = DashMap::new();
|
||||
let mut hl = Vec::new();
|
||||
build_headers(&i.client_headers, config.as_ref(), &mut hl);
|
||||
if !hl.is_empty() {
|
||||
match i.path.clone() {
|
||||
Some(path) => {
|
||||
header_list.insert(Arc::from(path.as_str()), hl);
|
||||
}
|
||||
None => {
|
||||
header_list.insert(Arc::from("/"), hl);
|
||||
}
|
||||
}
|
||||
// header_list.insert(i.path.clone().unwrap_or("/".to_string()), hl);
|
||||
let path_key = i.path.as_deref().unwrap_or("/");
|
||||
header_list.insert(Arc::from(path_key), hl);
|
||||
config.client_headers.insert(Arc::from(i.hostname.clone()), header_list);
|
||||
}
|
||||
|
||||
let pref = ss.clone() + &i.upstream;
|
||||
let list = httpclient::for_consul(pref.as_str(), consul.token.clone(), &i).await;
|
||||
list_to_upstreams(list, &upstreams, &i);
|
||||
let pref = format!("{}{}", ss, i.upstream);
|
||||
let list = httpclient::for_consul(pref.as_str(), consul.token.clone(), i).await;
|
||||
list_to_upstreams(list, &upstreams, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(lt) = clone_compare(&upstreams, &prev_upstreams, &config).await {
|
||||
toreturn.send(lt).await.unwrap();
|
||||
|
||||
if let Some(lt) = clone_compare(&upstreams, &config).await {
|
||||
let _ = toreturn.send(lt).await;
|
||||
}
|
||||
|
||||
sleep(Duration::from_secs(5)).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
async fn clone_compare(upstreams: &UpstreamsDashMap, prev_upstreams: &UpstreamsDashMap, config: &Arc<Configuration>) -> Option<Configuration> {
|
||||
if !compare_dashmaps(upstreams, prev_upstreams) {
|
||||
let tosend: Configuration = Configuration {
|
||||
|
||||
async fn clone_compare(upstreams: &UpstreamsDashMap, config: &Arc<Configuration>) -> Option<Configuration> {
|
||||
if !compare_dashmaps(upstreams, &config.upstreams) {
|
||||
let tosend = Configuration {
|
||||
upstreams: Default::default(),
|
||||
client_headers: config.client_headers.clone(),
|
||||
server_headers: config.server_headers.clone(),
|
||||
@@ -219,10 +268,11 @@ async fn clone_compare(upstreams: &UpstreamsDashMap, prev_upstreams: &UpstreamsD
|
||||
typecfg: config.typecfg.clone(),
|
||||
extraparams: config.extraparams.clone(),
|
||||
};
|
||||
clone_dashmap_into(upstreams, prev_upstreams);
|
||||
clone_dashmap_into(upstreams, &config.upstreams);
|
||||
clone_dashmap_into(upstreams, &tosend.upstreams);
|
||||
|
||||
print_upstreams(&tosend.upstreams, &tosend.extraparams);
|
||||
return Some(tosend);
|
||||
};
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
@@ -0,0 +1,271 @@
|
||||
use futures::StreamExt;
|
||||
use hyper::Uri;
|
||||
use k8s_openapi::api::core::v1::{Node, Service};
|
||||
use k8s_openapi::api::networking::v1::Ingress;
|
||||
use kube::api::{Patch, PatchParams};
|
||||
use kube::{
|
||||
api::Api,
|
||||
client::Client,
|
||||
config::{AuthInfo, Config},
|
||||
runtime::watcher::{self, Event},
|
||||
};
|
||||
use log::{error, info};
|
||||
use serde_json::json;
|
||||
use std::time::Duration;
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
pub struct AralezRouteUpdate {
|
||||
pub host: String,
|
||||
pub path: String,
|
||||
pub service_name: String,
|
||||
pub is_deleted: bool,
|
||||
pub rate_limit: Option<isize>,
|
||||
pub x4xx_limit: Option<u32>,
|
||||
pub sticky_sessions: Option<u64>,
|
||||
pub client_headers: Option<Vec<String>>,
|
||||
pub server_headers: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct AralezAnnotation {
|
||||
rate_limit: Option<isize>,
|
||||
x4xx_limit: Option<u32>,
|
||||
sticky_sessions: Option<u64>,
|
||||
pub client_headers: Option<Vec<String>>,
|
||||
pub server_headers: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
pub async fn start_ingress_watcher_with_config(
|
||||
api_server: &str,
|
||||
token: &str,
|
||||
tx: mpsc::Sender<AralezRouteUpdate>,
|
||||
target_class: &'static str,
|
||||
) -> Result<(), Box<dyn std::error::Error>> {
|
||||
let client = create_custom_k8s_client(api_server, token, true).await?;
|
||||
let ingresses: Api<Ingress> = Api::all(client.clone());
|
||||
|
||||
let watcher_config = watcher::Config::default().any_semantic();
|
||||
let mut stream = watcher::watcher(ingresses, watcher_config).boxed();
|
||||
|
||||
while let Some(event) = stream.next().await {
|
||||
match event {
|
||||
Ok(Event::Apply(ing)) => {
|
||||
process_ingress_change(&client, &ing, target_class, false, &tx).await;
|
||||
}
|
||||
Ok(Event::Delete(ing)) => {
|
||||
process_ingress_change(&client, &ing, target_class, true, &tx).await;
|
||||
}
|
||||
Ok(Event::InitApply(ing)) => {
|
||||
process_ingress_change(&client, &ing, target_class, false, &tx).await;
|
||||
}
|
||||
Ok(Event::InitDone) => {
|
||||
info!("Ingress watcher initial sync complete");
|
||||
}
|
||||
Err(err) => {
|
||||
error!("Kubernetes Ingress watch error: {:?}", err);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn process_ingress_change(client: &Client, ing: &Ingress, target_class: &str, is_deleted: bool, tx: &mpsc::Sender<AralezRouteUpdate>) {
|
||||
let spec = match &ing.spec {
|
||||
Some(s) => s,
|
||||
None => return,
|
||||
};
|
||||
let class_name = spec.ingress_class_name.as_deref().unwrap_or_default();
|
||||
if class_name != target_class {
|
||||
return;
|
||||
}
|
||||
|
||||
if !is_deleted {
|
||||
if let (Some(name), Some(ns)) = (ing.metadata.name.as_deref(), ing.metadata.namespace.as_deref()) {
|
||||
let svc_name = std::env::var("ARALEZ_SERVICE_NAME").unwrap_or_else(|_| "aralez-service".to_string());
|
||||
let external_ip = match discover_controller_ip(&client, ns, &svc_name).await {
|
||||
Some(ip) => ip,
|
||||
None => discover_node_ip(&client)
|
||||
.await
|
||||
.unwrap_or_else(|| std::env::var("ARALEZ_EXTERNAL_IP").unwrap_or_else(|_| "127.0.0.1".to_string())),
|
||||
};
|
||||
let client_clone = client.clone();
|
||||
let name_clone = name.to_string();
|
||||
let ns_clone = ns.to_string();
|
||||
let status = ing.status.clone();
|
||||
tokio::spawn(async move {
|
||||
patch_ingress_status_address(&client_clone, &ns_clone, &name_clone, status.as_ref(), &external_ip).await;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(rules) = &spec.rules {
|
||||
for rule in rules {
|
||||
let host = match &rule.host {
|
||||
Some(h) => h.clone(),
|
||||
None => "*".to_string(),
|
||||
};
|
||||
|
||||
if let Some(http) = &rule.http {
|
||||
for path_entry in &http.paths {
|
||||
let path = path_entry.path.clone().unwrap_or_else(|| "/".to_string());
|
||||
if let Some(service) = &path_entry.backend.service {
|
||||
let service_name = service.name.clone();
|
||||
let mut update = AralezRouteUpdate {
|
||||
host: host.clone(),
|
||||
path,
|
||||
service_name,
|
||||
is_deleted,
|
||||
rate_limit: None,
|
||||
x4xx_limit: None,
|
||||
sticky_sessions: None,
|
||||
client_headers: None,
|
||||
server_headers: None,
|
||||
};
|
||||
if let Some(annot) = parse_ingress_config(ing) {
|
||||
update.rate_limit = annot.rate_limit;
|
||||
update.x4xx_limit = annot.x4xx_limit;
|
||||
update.sticky_sessions = annot.sticky_sessions;
|
||||
update.client_headers = annot.client_headers;
|
||||
update.server_headers = annot.server_headers;
|
||||
}
|
||||
if let Err(e) = tx.send(update).await {
|
||||
error!("Failed to send route update to channel: {:?}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn create_custom_k8s_client(api_server_url: &str, bearer_token: &str, insecure_tls: bool) -> Result<Client, Box<dyn std::error::Error>> {
|
||||
let full_url = if !api_server_url.starts_with("http://") && !api_server_url.starts_with("https://") {
|
||||
format!("https://{}", api_server_url)
|
||||
} else {
|
||||
api_server_url.to_string()
|
||||
};
|
||||
let uri: Uri = full_url.parse()?;
|
||||
let mut config = Config::new(uri);
|
||||
config.auth_info = AuthInfo {
|
||||
token: Some(bearer_token.trim().to_string().into()),
|
||||
..Default::default()
|
||||
};
|
||||
config.connect_timeout = Some(Duration::from_secs(10));
|
||||
config.read_timeout = None;
|
||||
if insecure_tls {
|
||||
config.accept_invalid_certs = true;
|
||||
}
|
||||
let client = Client::try_from(config)?;
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
fn parse_ingress_config(ing: &Ingress) -> Option<AralezAnnotation> {
|
||||
if let Some(annotations) = &ing.metadata.annotations {
|
||||
let mut clh: Option<Vec<String>> = None;
|
||||
let mut srh: Option<Vec<String>> = None;
|
||||
|
||||
if let Some(ch) = annotations.get("aralez.rs/client_headers") {
|
||||
let data: Vec<String> = serde_json::from_str(ch).unwrap_or_default();
|
||||
clh = Some(data);
|
||||
}
|
||||
if let Some(sh) = annotations.get("aralez.rs/server_headers") {
|
||||
let data: Vec<String> = serde_json::from_str(sh).unwrap_or_default();
|
||||
srh = Some(data);
|
||||
};
|
||||
|
||||
let annots = AralezAnnotation {
|
||||
rate_limit: annotations.get("aralez.rs/rate_limit").and_then(|v| v.parse().ok()),
|
||||
x4xx_limit: annotations.get("aralez.rs/x4xx_limit").and_then(|v| v.parse().ok()),
|
||||
sticky_sessions: annotations.get("aralez.rs/sticky_sessions").and_then(|v| v.parse().ok()),
|
||||
client_headers: clh,
|
||||
server_headers: srh,
|
||||
};
|
||||
return Some(annots);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub async fn patch_ingress_status_address(
|
||||
client: &Client,
|
||||
namespace: &str,
|
||||
name: &str,
|
||||
current_status: Option<&k8s_openapi::api::networking::v1::IngressStatus>,
|
||||
external_ip: &str,
|
||||
) {
|
||||
if let Some(status) = current_status {
|
||||
if let Some(lb) = &status.load_balancer {
|
||||
if let Some(ing_list) = &lb.ingress {
|
||||
if ing_list.iter().any(|i| i.ip.as_deref() == Some(external_ip)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let ingresses: Api<Ingress> = Api::namespaced(client.clone(), namespace);
|
||||
|
||||
let patch = json!({
|
||||
"apiVersion": "networking.k8s.io/v1",
|
||||
"kind": "Ingress",
|
||||
"status": {
|
||||
"loadBalancer": {
|
||||
"ingress": [
|
||||
{
|
||||
"ip": external_ip
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let params = PatchParams::apply("aralez-ingress-controller").force();
|
||||
|
||||
match ingresses.patch_status(name, ¶ms, &Patch::Apply(patch)).await {
|
||||
Ok(_) => info!("Patched Ingress {}/{} ADDRESS to {}", namespace, name, external_ip),
|
||||
Err(e) => error!("Failed to patch status for Ingress {}/{}: {:?}", namespace, name, e),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn discover_node_ip(client: &Client) -> Option<String> {
|
||||
let nodes: Api<Node> = Api::all(client.clone());
|
||||
if let Ok(node_list) = nodes.list(&Default::default()).await {
|
||||
for node in node_list {
|
||||
if let Some(status) = node.status {
|
||||
if let Some(addresses) = status.addresses {
|
||||
for addr in &addresses {
|
||||
if addr.type_ == "ExternalIP" {
|
||||
return Some(addr.address.clone());
|
||||
}
|
||||
}
|
||||
for addr in &addresses {
|
||||
if addr.type_ == "InternalIP" {
|
||||
return Some(addr.address.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
pub async fn discover_controller_ip(client: &Client, namespace: &str, service_name: &str) -> Option<String> {
|
||||
let services: Api<Service> = Api::namespaced(client.clone(), namespace);
|
||||
if let Ok(svc) = services.get(service_name).await {
|
||||
if let Some(status) = svc.status {
|
||||
if let Some(lb) = status.load_balancer {
|
||||
if let Some(ingress_list) = lb.ingress {
|
||||
for ing in ingress_list {
|
||||
if let Some(ip) = ing.ip {
|
||||
return Some(ip);
|
||||
}
|
||||
if let Some(hostname) = ing.hostname {
|
||||
return Some(hostname);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
Reference in New Issue
Block a user