3. mc ls {{ template "minio.fullname" . }}-local

{{- end }}
{{- if eq .Values.service.type "LoadBalancer" }}
MinIO can be accessed via port {{ .Values.service.port }} on an external IP address. Get the service external IP address by:

    private String server;

    private int port;

    private String username;

    private String password;

    public String getServer() {
        return server;
    }

    public void setServer(final String server) {
        this.server = server;
    }

    public int getPort() {
        return port;
    }

    public void setPort(final int port) {
        this.port = port;
    }

  @Throws(IOException::class)
  override fun createServerSocket(port: Int): ServerSocket {
    val serverSocket = delegate.createServerSocket(port)
    return configureServerSocket(serverSocket)
  }

  @Throws(IOException::class)
  override fun createServerSocket(
    port: Int,
    backlog: Int,
  ): ServerSocket {
    val serverSocket = delegate.createServerSocket(port, backlog)
    return configureServerSocket(serverSocket)
  }

import (
	"fmt"
	"net/url"
	"strings"
)

func isMCPAddr(u *url.URL) bool {
	return strings.HasSuffix(u.Host, ".googleapis.com") || strings.HasSuffix(u.Host, ".googleapis.com:443")
}

func parseMCPAddr(u *url.URL) (*xdsAddr, error) {
	ret := &xdsAddr{host: u.Host}
	if !strings.HasSuffix(ret.host, ":443") {
		ret.host += ":443"
	}
	const projSeg = "/projects/"
	i := strings.Index(u.Path, projSeg)
	if i == -1 {

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
)

var port int

func init() {
	flag.IntVar(&port, "port", 8080, "Port to listen on")
}

func mainHandler(w http.ResponseWriter, r *http.Request) {
	body, err := io.ReadAll(r.Body)
	defer r.Body.Close()
	if err != nil {

    private final String host;

    BasicAuthInterceptor(String host, String username, String password) {
      this.credentials = Credentials.basic(username, password);
      this.host = host;
    }

    @Override public Response intercept(Chain chain) throws IOException {
      Request request = chain.request();
      if (request.url().host().equals(host)) {
        request = request.newBuilder()

        this.password = value;
    }

    public Integer getPort() {
        checkSpecifiedProperty("port");
        return port;
    }

    public void setPort(Integer value) {
        registerModifiedProperty("port");
        this.port = value;
    }

    public String getProtocolScheme() {
        checkSpecifiedProperty("protocolScheme");

    /**
     * The default HTTPS port (<code>443</code>).
     */
    public static final int DEFAULT_HTTPS_PORT = 443;


    /**
     * @param tc
     *            context to use
     * 
     */
    public Handler ( CIFSContext tc ) {
        super(tc);
    }


    /**
     * Returns the default HTTPS port.
     *

    public void setPort_Equal(Integer port) {
        setPort_Term(port, null);
    }

    public void setPort_Equal(Integer port, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setPort_Term(port, opLambda);
    }

    public void setPort_Term(Integer port) {
        setPort_Term(port, null);
    }

    public void setPort_Term(Integer port, ConditionOptionCall<TermQueryBuilder> opLambda) {

RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

COPY ./app /code/app

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

# If running behind a proxy like Nginx or Traefik add --proxy-headers
# CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80", "--proxy-headers"]
```

</details>

## コンテナとは何か