github.com/IBM-Cloud/bluemix-go@v0.0.0-20240423071914-9e96525baef4/examples/container/V2containers/IngressV2/main.go (about)

     1  package main
     2  
     3  import (
     4  	"flag"
     5  	"fmt"
     6  	"log"
     7  	"os"
     8  
     9  	v2 "github.com/IBM-Cloud/bluemix-go/api/container/containerv2"
    10  	"github.com/IBM-Cloud/bluemix-go/session"
    11  	"github.com/IBM-Cloud/bluemix-go/trace"
    12  )
    13  
    14  func main() {
    15  
    16  	var certcrn, clusterID, instancecrn, fieldcrn string
    17  	flag.StringVar(&certcrn, "certcrn", "", "CRN for certificate")
    18  	flag.StringVar(&clusterID, "clusterNameOrID", "", "cluster name or ID")
    19  	flag.StringVar(&instancecrn, "instance-crn", "", "crn for secrets manager instance")
    20  	flag.StringVar(&fieldcrn, "field-crn", "", "crn for opaque secret field")
    21  	flag.Parse()
    22  
    23  	trace.Logger = trace.NewLogger("true")
    24  	if clusterID == "" {
    25  		flag.Usage()
    26  		os.Exit(1)
    27  	}
    28  
    29  	sess, err := session.New()
    30  	if err != nil {
    31  		log.Fatal(err)
    32  	}
    33  	ingressClient, err := v2.New(sess)
    34  	if err != nil {
    35  		log.Fatal(err)
    36  	}
    37  	ingressAPI := ingressClient.Ingresses()
    38  
    39  	if instancecrn != "" {
    40  		if err := instance(ingressAPI, clusterID, instancecrn); err != nil {
    41  			fmt.Println("err=", err)
    42  			os.Exit(1)
    43  		}
    44  	}
    45  
    46  	if certcrn != "" {
    47  		if err := secret(ingressAPI, clusterID, certcrn); err != nil {
    48  			fmt.Println("err=", err)
    49  			os.Exit(1)
    50  		}
    51  	}
    52  
    53  	if fieldcrn != "" {
    54  		if err := opaqueSecret(ingressAPI, clusterID, fieldcrn); err != nil {
    55  			fmt.Println("err=", err)
    56  			os.Exit(1)
    57  		}
    58  	}
    59  }
    60  
    61  func secret(ingressAPI v2.Ingress, clusterID, certCRN string) error {
    62  	trace.Logger = trace.NewLogger("true")
    63  	if certCRN == "" || clusterID == "" {
    64  		flag.Usage()
    65  		os.Exit(1)
    66  	}
    67  
    68  	// CREATE INGRESS SECRET
    69  	req := v2.SecretCreateConfig{
    70  		Cluster:     clusterID,
    71  		Name:        "testabc123",
    72  		CRN:         certCRN,
    73  		Persistence: true,
    74  	}
    75  	resp, err := ingressAPI.CreateIngressSecret(req)
    76  	if err != nil {
    77  		return err
    78  	}
    79  
    80  	// Get INGRESS SECRET
    81  	_, err = ingressAPI.GetIngressSecret(clusterID, "testabc123", resp.Namespace)
    82  	if err != nil {
    83  		return err
    84  	}
    85  
    86  	// Delete INGRESS SECRET
    87  	req1 := v2.SecretDeleteConfig{
    88  		Cluster:   clusterID,
    89  		Name:      "testabc123",
    90  		Namespace: resp.Namespace,
    91  	}
    92  	return ingressAPI.DeleteIngressSecret(req1)
    93  }
    94  
    95  func opaqueSecret(ingressAPI v2.Ingress, clusterID, fieldCRN string) error {
    96  	trace.Logger = trace.NewLogger("true")
    97  	if fieldCRN == "" || clusterID == "" {
    98  		flag.Usage()
    99  		os.Exit(1)
   100  	}
   101  
   102  	// CREATE INGRESS SECRET
   103  	req := v2.SecretCreateConfig{
   104  		Cluster:     clusterID,
   105  		Name:        "testabc123",
   106  		Persistence: true,
   107  		Type:        "Opaque",
   108  		FieldsToAdd: []v2.FieldAdd{{
   109  			CRN: fieldCRN,
   110  		}},
   111  	}
   112  	resp, err := ingressAPI.CreateIngressSecret(req)
   113  	if err != nil {
   114  		return err
   115  	}
   116  
   117  	// Get INGRESS SECRET
   118  	secret, err := ingressAPI.GetIngressSecret(clusterID, "testabc123", resp.Namespace)
   119  	if err != nil {
   120  		return err
   121  	}
   122  
   123  	// Add INGRESS SECRET field
   124  	req1 := v2.SecretUpdateConfig{
   125  		Cluster:   clusterID,
   126  		Name:      "testabc123",
   127  		Namespace: resp.Namespace,
   128  		FieldsToRemove: []v2.FieldRemove{{
   129  			Name: secret.Fields[0].Name,
   130  		}},
   131  	}
   132  
   133  	_, err = ingressAPI.RemoveIngressSecretField(req1)
   134  	if err != nil {
   135  		return err
   136  	}
   137  
   138  	// Delete INGRESS SECRET
   139  	req2 := v2.SecretDeleteConfig{
   140  		Cluster:   clusterID,
   141  		Name:      "testabc123",
   142  		Namespace: resp.Namespace,
   143  	}
   144  	return ingressAPI.DeleteIngressSecret(req2)
   145  }
   146  
   147  func instance(ingressAPI v2.Ingress, clusterID, instanceCRN string) error {
   148  	trace.Logger = trace.NewLogger("true")
   149  	if instanceCRN == "" || clusterID == "" {
   150  		flag.Usage()
   151  		os.Exit(1)
   152  	}
   153  
   154  	// CREATE INGRESS SECRET
   155  	req := v2.InstanceRegisterConfig{
   156  		Cluster: clusterID,
   157  		CRN:     instanceCRN,
   158  	}
   159  	resp, err := ingressAPI.RegisterIngressInstance(req)
   160  	if err != nil {
   161  		return err
   162  	}
   163  
   164  	// Get INGRESS SECRET
   165  	_, err = ingressAPI.GetIngressInstance(clusterID, resp.Name)
   166  	if err != nil {
   167  		return err
   168  	}
   169  
   170  	// Delete INGRESS SECRET
   171  	req1 := v2.InstanceDeleteConfig{
   172  		Cluster: clusterID,
   173  		Name:    resp.Name,
   174  	}
   175  	return ingressAPI.DeleteIngressInstance(req1)
   176  }