> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Demo Accessing MinIO

> Guide to access and inspect the Argo Workflows bundled MinIO artifact repository, including exposing the UI, retrieving credentials, browsing artifacts, and verifying archived workflow logs.

This guide shows how to access the default MinIO artifact repository installed by the Argo Workflows quick-start / minimal configuration. The bundled MinIO server stores workflow artifacts and archived logs so you can inspect them from a web UI or via S3-compatible tools.

## 1. Confirm MinIO pod and service are running

First, verify the MinIO pod and service exist in the `argo` namespace:

```bash theme={null}
kubectl -n argo get po,svc | grep -i minio
```

Example output:

```bash theme={null}
pod/minio-5cb4ff75c9-stmmw   1/1   Running   0   4h40m
service/minio               ClusterIP   10.108.36.67   <none>   9000/TCP,9001/TCP   4h40m
```

By default the service is a ClusterIP and not directly reachable from outside the cluster.

## 2. Expose the MinIO web UI (quick demo options)

To view the MinIO web console in your browser you can either:

* Change the Service to a NodePort (quick one-off demo), or
* Use `kubectl port-forward` (recommended for local access without changing cluster services), or
* Configure an Ingress with authentication for production.

Quick method: edit the MinIO service and change the type to `NodePort`:

```bash theme={null}
kubectl -n argo edit svc minio
# change "type: ClusterIP" to "type: NodePort" and save
```

After editing, confirm the NodePort mapping:

```bash theme={null}
kubectl -n argo get po,svc | grep -i minio
```

Example output showing NodePorts (9000 and 9001 mapped to high-numbered node ports):

```bash theme={null}
pod/minio-5cb4ff75c9-stmmw   1/1   Running   0   4h40m
service/minio               NodePort    10.108.36.67   <none>   9000:30648/TCP,9001:30731/TCP   4h40m
```

* Internal MinIO UI port: 9001
* Example NodePort for the UI: `30731` (your cluster will assign different high ports)

Table: quick port summary

| Internal port | Example NodePort | Purpose                             |
| ------------- | ---------------: | ----------------------------------- |
| 9000          |            30648 | S3 API endpoint (object operations) |
| 9001          |            30731 | MinIO web console (UI)              |

Note: For secure/demo access without changing services, you can run:

```bash theme={null}
kubectl -n argo port-forward svc/minio 9001:9001
# then open http://localhost:9001 in your browser
```

## 3. Retrieve MinIO credentials

Argo stores the MinIO credentials as Kubernetes secrets in the `argo` namespace. Decode them with:

```bash theme={null}
kubectl -n argo get secrets my-minio-cred -o json | jq -r .data.accesskey | base64 --decode
kubectl -n argo get secrets my-minio-cred -o json | jq -r .data.secretkey | base64 --decode
```

Example output:

```text theme={null}
admin
adminpassword
```

Use these values to sign in to the MinIO web console (NodePort or port-forward URL).

## 4. Browse buckets and archived workflow logs

Once authenticated, you will see buckets created by Argo Workflows (for example `my-bucket`) and the objects within. These objects include archived logs and workflow artifacts produced by completed runs.

If you browse into a bucket you will see items corresponding to workflows and their logs:

<Frame>
  <img src="https://mintcdn.com/kodekloud-c4ac6d9a/v7HW2PPNQOGxY8Ve/images/Prep-Course-Certified-Argo-Project-Associate-CAPA/Argo-Workflow/Demo-Accessing-MinIO/minio-web-console-my-bucket-contents.jpg?fit=max&auto=format&n=v7HW2PPNQOGxY8Ve&q=85&s=6d29a95948c70ff6add2c9a900ba57c1" alt="A screenshot of the MinIO Object Store web console showing the contents of a bucket named &#x22;my-bucket&#x22; with a list of object/folder names (e.g., cowsay-template, daemon-workflow, retry-workflow). The left sidebar shows navigation items like Buckets, Access Keys, and Administrator settings." width="1920" height="1080" data-path="images/Prep-Course-Certified-Argo-Project-Associate-CAPA/Argo-Workflow/Demo-Accessing-MinIO/minio-web-console-my-bucket-contents.jpg" />
</Frame>

All completed workflow logs are persisted to the MinIO object store by default when Argo is configured to archive logs.

## 5. Inspect the `artifact-repositories` ConfigMap

Argo’s artifact repository configuration (which controls archiving behavior and S3/MinIO connection details) lives in a ConfigMap named `artifact-repositories` in the `argo` namespace. View it with:

```bash theme={null}
kubectl -n argo get cm artifact-repositories -o yaml
```

Example excerpt (showing the relevant `default-v1` entry):

```yaml theme={null}
apiVersion: v1
data:
  default-v1: |
    archiveLogs: true
    s3:
      bucket: my-bucket
      endpoint: minio:9000
      insecure: true
      accessKeySecret:
        name: my-minio-cred
        key: accesskey
      secretKeySecret:
        name: my-minio-cred
        key: secretkey
kind: ConfigMap
metadata:
  name: artifact-repositories
  namespace: argo
```

Key points:

* archiveLogs: true — instructs Argo to persist workflow logs to the artifact store.
* endpoint: minio:9000 — hostname and port of the S3-compatible MinIO service as seen from within the cluster.
* Credentials are referenced via the `my-minio-cred` secret.

<Callout icon="lightbulb" color="#1CB2FE">
  The quick-start bundles MinIO for convenience and local testing. For production use, point Argo to a managed S3-compatible provider (e.g., AWS S3, Google Cloud Storage) and manage credentials using a secure secrets workflow.
</Callout>

<Callout icon="warning" color="#FF6B6B">
  Do not expose MinIO (or any artifact store) publicly without proper authentication and network restrictions. For ad-hoc demos, prefer `kubectl port-forward` or restrict NodePort access to trusted networks.
</Callout>

## 6. Verify artifact uploads

Because `archiveLogs: true`, completed workflow logs appear in the configured bucket automatically. To test artifact uploads, run a workflow that produces an artifact (or archive logs) and then check the bucket in the MinIO console or via an S3 client:

Example quick verification with `mc` (MinIO client) after port-forward or using NodePort with S3 endpoint:

```bash theme={null}
# Example: using AWS CLI S3-compatible endpoint (set AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY)
aws --endpoint-url http://localhost:9000 s3 ls s3://my-bucket
```

Replace endpoint and credentials to match your environment.

## Links and references

* Argo Workflows — [https://argoproj.github.io/argo-workflows/](https://argoproj.github.io/argo-workflows/)
* Kubernetes documentation — [https://kubernetes.io/docs/](https://kubernetes.io/docs/)
* MinIO documentation — [https://min.io/docs/](https://min.io/docs/)
* jq JSON processor — [https://stedolan.github.io/jq/](https://stedolan.github.io/jq/)
* AWS S3 — [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/)
* Google Cloud Storage — [https://cloud.google.com/storage](https://cloud.google.com/storage)

This process helps you access, inspect, and verify artifacts and archived logs stored by the Argo Workflows' bundled MinIO server.

<CardGroup>
  <Card title="Watch Video" icon="video" cta="Learn more" href="https://learn.kodekloud.com/user/courses/certified-argo-project-associate-capa/module/44223b5d-ccc3-4dcb-8292-66036e2ea023/lesson/37cae24d-46ec-4607-a662-3b3b990d95d8" />
</CardGroup>