[nexus][sled-agent] DNS services are backed by explicit datasets

common/src/sql/dbinit.sql

@@ -385,7 +385,9 @@ CREATE TABLE omicron.public.Zpool (
 CREATE TYPE omicron.public.dataset_kind AS ENUM (
   'crucible',
   'cockroach',
-  'clickhouse'
+  'clickhouse',
+  'external_dns',
+  'internal_dns'
 );
 
 /*

nexus/db-model/src/dataset_kind.rs

@@ -19,6 +19,8 @@ impl_enum_type!(
     Crucible => b"crucible"
     Cockroach => b"cockroach"
     Clickhouse => b"clickhouse"
+    ExternalDns => b"external_dns"
+    InternalDns => b"internal_dns"
 );
 
 impl From<internal_api::params::DatasetKind> for DatasetKind {
@@ -33,6 +35,12 @@ impl From<internal_api::params::DatasetKind> for DatasetKind {
             internal_api::params::DatasetKind::Clickhouse => {
                 DatasetKind::Clickhouse
             }
+            internal_api::params::DatasetKind::ExternalDns => {
+                DatasetKind::ExternalDns
+            }
+            internal_api::params::DatasetKind::InternalDns => {
+                DatasetKind::InternalDns
+            }
         }
     }
 }

nexus/types/src/internal_api/params.rs

@@ -17,7 +17,6 @@ use std::fmt;
 use std::net::IpAddr;
 use std::net::SocketAddr;
 use std::net::SocketAddrV6;
-use std::str::FromStr;
 use uuid::Uuid;
 
 /// Describes the role of the sled within the rack.
@@ -134,6 +133,8 @@ pub enum DatasetKind {
     Crucible,
     Cockroach,
     Clickhouse,
+    ExternalDns,
+    InternalDns,
 }
 
 impl fmt::Display for DatasetKind {
@@ -143,27 +144,13 @@ impl fmt::Display for DatasetKind {
             Crucible => "crucible",
             Cockroach => "cockroach",
             Clickhouse => "clickhouse",
+            ExternalDns => "external_dns",
+            InternalDns => "internal_dns",
         };
         write!(f, "{}", s)
     }
 }
 
-impl FromStr for DatasetKind {
-    type Err = omicron_common::api::external::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        use DatasetKind::*;
-        match s {
-            "crucible" => Ok(Crucible),
-            "cockroach" => Ok(Cockroach),
-            "clickhouse" => Ok(Clickhouse),
-            _ => Err(Self::Err::InternalError {
-                internal_message: format!("Unknown dataset kind: {}", s),
-            }),
-        }
-    }
-}
-
 /// Describes a dataset within a pool.
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct DatasetPutRequest {

openapi/nexus-internal.json

@@ -931,7 +931,9 @@
         "enum": [
           "crucible",
           "cockroach",
-          "clickhouse"
+          "clickhouse",
+          "external_dns",
+          "internal_dns"
         ]
       },
       "DatasetPutRequest": {

openapi/sled-agent.json

@@ -617,6 +617,12 @@
           "dataset_kind": {
             "$ref": "#/components/schemas/DatasetKind"
           },
+          "gz_address": {
+            "nullable": true,
+            "default": null,
+            "type": "string",
+            "format": "ipv6"
+          },
           "id": {
             "type": "string",
             "format": "uuid"
@@ -677,6 +683,63 @@
             "required": [
               "type"
             ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "dns_address": {
+                "description": "The address at which the external DNS server is reachable.",
+                "type": "string"
+              },
+              "http_address": {
+                "description": "The address at which the external DNS server API is reachable.",
+                "type": "string"
+              },
+              "nic": {
+                "description": "The service vNIC providing external connectivity using OPTE.",
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/NetworkInterface"
+                  }
+                ]
+              },
+              "type": {
+                "type": "string",
+                "enum": [
+                  "external_dns"
+                ]
+              }
+            },
+            "required": [
+              "dns_address",
+              "http_address",
+              "nic",
+              "type"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "dns_address": {
+                "description": "The address at which the internal DNS server is reachable.",
+                "type": "string"
+              },
+              "http_address": {
+                "description": "The address at which the internal DNS server API is reachable.",
+                "type": "string"
+              },
+              "type": {
+                "type": "string",
+                "enum": [
+                  "internal_dns"
+                ]
+              }
+            },
+            "required": [
+              "dns_address",
+              "http_address",
+              "type"
+            ]
           }
         ]
       },

sled-agent/src/http_entrypoints.rs

@@ -124,6 +124,7 @@ async fn filesystem_put(
         body_args.zpool_id,
         body_args.dataset_kind,
         body_args.address,
+        body_args.gz_address,
     )
     .await
     .map_err(|e| Error::from(e))?;

sled-agent/src/params.rs

@@ -216,6 +216,20 @@ pub enum DatasetKind {
     CockroachDb,
     Crucible,
     Clickhouse,
+    ExternalDns {
+        /// The address at which the external DNS server API is reachable.
+        http_address: SocketAddrV6,
+        /// The address at which the external DNS server is reachable.
+        dns_address: SocketAddr,
+        /// The service vNIC providing external connectivity using OPTE.
+        nic: NetworkInterface,
+    },
+    InternalDns {
+        /// The address at which the internal DNS server API is reachable.
+        http_address: SocketAddrV6,
+        /// The address at which the internal DNS server is reachable.
+        dns_address: SocketAddrV6,
+    },
 }
 
 impl DatasetKind {
@@ -225,6 +239,8 @@ impl DatasetKind {
             DatasetKind::CockroachDb => ZoneType::CockroachDb,
             DatasetKind::Crucible => ZoneType::Crucible,
             DatasetKind::Clickhouse => ZoneType::Clickhouse,
+            DatasetKind::ExternalDns { .. } => ZoneType::ExternalDns,
+            DatasetKind::InternalDns { .. } => ZoneType::InternalDns,
         }
     }
 
@@ -234,10 +250,16 @@ impl DatasetKind {
     /// service in their zone. If that precondition is no longer true, this
     /// interface should be re-visited.
     pub fn service_type(&self) -> ServiceType {
-        match *self {
+        match self.clone() {
             DatasetKind::CockroachDb => ServiceType::CockroachDb,
             DatasetKind::Crucible => ServiceType::Crucible,
             DatasetKind::Clickhouse => ServiceType::Clickhouse,
+            DatasetKind::ExternalDns { http_address, dns_address, nic } => {
+                ServiceType::ExternalDns { http_address, dns_address, nic }
+            }
+            DatasetKind::InternalDns { http_address, dns_address } => {
+                ServiceType::InternalDns { http_address, dns_address }
+            }
         }
     }
 }
@@ -249,6 +271,17 @@ impl From<DatasetKind> for sled_agent_client::types::DatasetKind {
             CockroachDb => Self::CockroachDb,
             Crucible => Self::Crucible,
             Clickhouse => Self::Clickhouse,
+            ExternalDns { http_address, dns_address, nic } => {
+                Self::ExternalDns {
+                    http_address: http_address.to_string(),
+                    dns_address: dns_address.to_string(),
+                    nic: nic.into(),
+                }
+            }
+            InternalDns { http_address, dns_address } => Self::InternalDns {
+                http_address: http_address.to_string(),
+                dns_address: dns_address.to_string(),
+            },
         }
     }
 }
@@ -260,6 +293,8 @@ impl From<DatasetKind> for nexus_client::types::DatasetKind {
             CockroachDb { .. } => Self::Cockroach,
             Crucible => Self::Crucible,
             Clickhouse => Self::Clickhouse,
+            ExternalDns { .. } => Self::ExternalDns,
+            InternalDns { .. } => Self::InternalDns,
         }
     }
 }
@@ -271,6 +306,8 @@ impl std::fmt::Display for DatasetKind {
             Crucible => "crucible",
             CockroachDb { .. } => "cockroachdb",
             Clickhouse => "clickhouse",
+            ExternalDns { .. } => "external_dns",
+            InternalDns { .. } => "internal_dns",
         };
         write!(f, "{}", s)
     }
@@ -290,6 +327,10 @@ pub struct DatasetEnsureBody {
     pub dataset_kind: DatasetKind,
     // The address on which the zone will listen for requests.
     pub address: SocketAddrV6,
+    // The addresses in the global zone which should be created, if necessary
+    // to route to the service.
+    #[serde(default)]
+    pub gz_address: Option<Ipv6Addr>,
 }
 
 impl From<DatasetEnsureBody> for sled_agent_client::types::DatasetEnsureBody {
@@ -298,6 +339,7 @@ impl From<DatasetEnsureBody> for sled_agent_client::types::DatasetEnsureBody {
             zpool_id: p.zpool_id,
             dataset_kind: p.dataset_kind.into(),
             address: p.address.to_string(),
+            gz_address: p.gz_address,
             id: p.id,
         }
     }