chore: optimize runtime environment container configuration

agent/app/dto/request/runtime.go

@@ -42,12 +42,14 @@ type Environment struct {
 type Volume struct {
 	Source string `json:"source"`
 	Target string `json:"target"`
+	Mode   string `json:"mode"`
 }
 
 type ExposedPort struct {
 	HostPort      int    `json:"hostPort"`
 	ContainerPort int    `json:"containerPort"`
 	HostIP        string `json:"hostIP"`
+	Protocol      string `json:"protocol"`
 }
 
 type ExtraHost struct {

agent/app/service/app_utils.go

@@ -89,7 +89,15 @@ func checkPort(key string, params map[string]interface{}) (int, error) {
 	return 0, nil
 }
 
+func isPortInUse(port int, protocol string) bool {
+	return common.ScanPortWithProto(port, normalizeComposeProtocol(protocol))
+}
+
 func checkPortExist(port int) error {
+	return checkPortExistWithProtocol(port, "")
+}
+
+func checkPortExistWithProtocol(port int, protocol string) error {
 	errMap := make(map[string]interface{})
 	errMap["port"] = port
 	appInstall, _ := appInstallRepo.GetFirst(appInstallRepo.WithPort(port))
@@ -110,7 +118,7 @@ func checkPortExist(port int) error {
 		errMap["name"] = domain.Domain
 		return buserr.WithMap("ErrPortExist", errMap, nil)
 	}
-	if common.ScanPort(port) {
+	if isPortInUse(port, protocol) {
 		return buserr.WithDetail("ErrPortInUsed", port, nil)
 	}
 	return nil

agent/app/service/docker_compose_config.go

@@ -0,0 +1,84 @@
+package service
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
+)
+
+func composePortEnvKeys(index int) (containerPort, hostPort, hostIP, protocol string) {
+	return fmt.Sprintf("CONTAINER_PORT_%d", index),
+		fmt.Sprintf("HOST_PORT_%d", index),
+		fmt.Sprintf("HOST_IP_%d", index),
+		fmt.Sprintf("PORT_PROTOCOL_%d", index)
+}
+
+func isComposePortEnvKey(key string) bool {
+	return strings.HasPrefix(key, "CONTAINER_PORT_") ||
+		strings.HasPrefix(key, "HOST_PORT_") ||
+		strings.HasPrefix(key, "HOST_IP_") ||
+		strings.HasPrefix(key, "PORT_PROTOCOL_")
+}
+
+func formatComposePortMapping(hostIP, hostPort, containerPort, protocol string) string {
+	return fmt.Sprintf("${%s}:${%s}:${%s}/%s", hostIP, hostPort, containerPort, normalizeComposeProtocol(protocol))
+}
+
+func normalizeComposeProtocol(protocol string) string {
+	switch strings.ToLower(strings.TrimSpace(protocol)) {
+	case "udp":
+		return "udp"
+	default:
+		return "tcp"
+	}
+}
+
+func formatComposeVolume(source, target, mode string) string {
+	return fmt.Sprintf("%s:%s:%s", source, target, normalizeComposeVolumeMode(mode))
+}
+
+func normalizeComposeVolumeMode(mode string) string {
+	switch strings.ToLower(strings.TrimSpace(mode)) {
+	case "ro":
+		return "ro"
+	default:
+		return "rw"
+	}
+}
+
+func loadComposeExposedPortsFromEnv(envs map[string]string, defaultHostIP string, strict bool) ([]request.ExposedPort, error) {
+	var ports []request.ExposedPort
+	for key, value := range envs {
+		if !strings.HasPrefix(key, "CONTAINER_PORT_") {
+			continue
+		}
+		index := strings.TrimPrefix(key, "CONTAINER_PORT_")
+		containerPort, err := strconv.Atoi(value)
+		if err != nil {
+			if strict {
+				return nil, err
+			}
+			continue
+		}
+		hostPort, err := strconv.Atoi(envs["HOST_PORT_"+index])
+		if err != nil {
+			if strict {
+				return nil, err
+			}
+			continue
+		}
+		hostIP := envs["HOST_IP_"+index]
+		if hostIP == "" {
+			hostIP = defaultHostIP
+		}
+		ports = append(ports, request.ExposedPort{
+			ContainerPort: containerPort,
+			HostPort:      hostPort,
+			HostIP:        hostIP,
+			Protocol:      normalizeComposeProtocol(envs["PORT_PROTOCOL_"+index]),
+		})
+	}
+	return ports, nil
+}

agent/app/service/mcp_server.go

@@ -792,9 +792,14 @@ func loadMcpServerComposeConfig(serverDTO *response.McpServerDTO) error {
 		}
 		if service.Volumes != nil {
 			for _, volume := range service.Volumes {
+				mode := "rw"
+				if volume.ReadOnly {
+					mode = "ro"
+				}
 				serverDTO.Volumes = append(serverDTO.Volumes, request.Volume{
 					Source: volume.Source,
 					Target: volume.Target,
+					Mode:   mode,
 				})
 			}
 		}
@@ -850,6 +855,9 @@ func handleCreateParams(mcpServer *model.McpServer, environments []request.Envir
 	normalizeMcpServerGateway(mcpServer)
 	serviceValue["command"] = buildSupergatewayCommand(mcpServer)
 	serviceValue["image"] = mcpServer.GatewayImage
+	serviceValue["ports"] = []string{
+		formatComposePortMapping("HOST_IP", "PANEL_APP_PORT_HTTP", "PANEL_APP_PORT_HTTP", ""),
+	}
 	oldEnv, hasOldEnv := serviceValue["environment"]
 	delete(serviceValue, "environment")
 	if environments != nil && len(environments) > 0 {
@@ -869,7 +877,7 @@ func handleCreateParams(mcpServer *model.McpServer, environments []request.Envir
 	if volumes != nil && len(volumes) > 0 {
 		volumeList := make([]string, 0)
 		for _, volume := range volumes {
-			volumeList = append(volumeList, fmt.Sprintf("%s:%s", volume.Source, volume.Target))
+			volumeList = append(volumeList, formatComposeVolume(volume.Source, volume.Target, volume.Mode))
 		}
 		serviceValue["volumes"] = volumeList
 	} else if volumes == nil {

agent/app/service/runtime.go

@@ -137,7 +137,7 @@ func (r *RuntimeService) Create(create request.RuntimeCreate) (*model.Runtime, e
 		create.Install = true
 		for _, export := range create.ExposedPorts {
 			hostPorts = append(hostPorts, strconv.Itoa(export.HostPort))
-			if err := checkPortExist(export.HostPort); err != nil {
+			if err := checkPortExistWithProtocol(export.HostPort, export.Protocol); err != nil {
 				return nil, err
 			}
 		}
@@ -241,30 +241,11 @@ func (r *RuntimeService) Page(req request.RuntimeSearch) (int64, []response.Runt
 			runtimeDTO.AppID = detail.AppId
 		}
 		for k, v := range envs {
-			runtimeDTO.Params[k] = v
-			if strings.Contains(k, "CONTAINER_PORT") || strings.Contains(k, "HOST_PORT") {
-				if strings.Contains(k, "CONTAINER_PORT") {
-					matches := re.GetRegex(re.TrailingDigitsPattern).FindStringSubmatch(k)
-					if len(matches) < 2 {
-						continue
-					}
-					containerPort, err := strconv.Atoi(v)
-					if err != nil {
-						continue
-					}
-					hostPort, err := strconv.Atoi(envs[fmt.Sprintf("HOST_PORT_%s", matches[1])])
-					if err != nil {
-						continue
-					}
-					hostIP := envs[fmt.Sprintf("HOST_IP_%s", matches[1])]
-					runtimeDTO.ExposedPorts = append(runtimeDTO.ExposedPorts, request.ExposedPort{
-						ContainerPort: containerPort,
-						HostPort:      hostPort,
-						HostIP:        hostIP,
-					})
-				}
+			if !isComposePortEnvKey(k) {
+				runtimeDTO.Params[k] = v
 			}
 		}
+		runtimeDTO.ExposedPorts, _ = loadComposeExposedPortsFromEnv(envs, "", false)
 		res = append(res, runtimeDTO)
 	}
 	return total, res, nil
@@ -435,9 +416,11 @@ func (r *RuntimeService) Update(req request.RuntimeUpdate) error {
 			return buserr.New("ErrImageExist")
 		}
 	case constant.RuntimeNode, constant.RuntimeJava, constant.RuntimeGo, constant.RuntimePython, constant.RuntimeDotNet:
+		ownedPortKeys := runtimeOwnedPortKeys(runtime.Env)
 		for _, export := range req.ExposedPorts {
 			hostPorts = append(hostPorts, strconv.Itoa(export.HostPort))
-			if err = checkRuntimePortExist(export.HostPort, false, runtime.ID); err != nil {
+			_, owned := ownedPortKeys[composePortCheckKey(export.HostPort, export.Protocol)]
+			if err = checkRuntimePortExistWithProtocol(export.HostPort, export.Protocol, !owned, runtime.ID); err != nil {
 				return err
 			}
 		}
@@ -1058,14 +1041,16 @@ func (r *RuntimeService) UpdatePHPContainer(req request.PHPContainerConfig) erro
 	var (
 		composeContent []byte
 	)
+	ownedPortKeys := runtimeOwnedPortKeys(runtime.Env)
 	for _, export := range req.ExposedPorts {
 		if strconv.Itoa(export.HostPort) == runtime.Port {
 			return buserr.WithName("ErrPHPRuntimePortFailed", strconv.Itoa(export.HostPort))
 		}
 		if export.ContainerPort == 9000 {
 			return buserr.New("ErrPHPPortIsDefault")
 		}
-		if err = checkRuntimePortExist(export.HostPort, false, runtime.ID); err != nil {
+		_, owned := ownedPortKeys[composePortCheckKey(export.HostPort, export.Protocol)]
+		if err = checkRuntimePortExistWithProtocol(export.HostPort, export.Protocol, !owned, runtime.ID); err != nil {
 			return err
 		}
 	}
@@ -1090,7 +1075,7 @@ func (r *RuntimeService) UpdatePHPContainer(req request.PHPContainerConfig) erro
 		return err
 	}
 	for k := range envs {
-		if strings.HasPrefix(k, "CONTAINER_PORT_") || strings.HasPrefix(k, "HOST_PORT_") || strings.HasPrefix(k, "HOST_IP_") || strings.Contains(k, "APP_PORT") {
+		if isComposePortEnvKey(k) || strings.Contains(k, "APP_PORT") {
 			delete(envs, k)
 		}
 	}
@@ -1102,6 +1087,7 @@ func (r *RuntimeService) UpdatePHPContainer(req request.PHPContainerConfig) erro
 			ExposedPorts: req.ExposedPorts,
 			Environments: req.Environments,
 			Volumes:      req.Volumes,
+			ExtraHosts:   req.ExtraHosts,
 		},
 	}
 	composeContent, err = handleCompose(envs, composeContent, create, projectDir)