Go でCLIツールを作る

.
├── LICENSE
├── Makefile
├── cmd
│   ├── ecs-exec-sh
│   │   └── main.go
│   └── root.go
├── go.mod
└── go.sum

/*
Copyright © 2024 NAME HERE <EMAIL ADDRESS>
*/
package cmd

import (
	"context"
	"fmt"
	"os"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/ecs"
	ecsShell "github.com/snaka/ecs-exec-sh/ecs"
	"github.com/spf13/cobra"
)

// listCmd represents the list command
var listCmd = &cobra.Command{
	Use:   "list",
	Short: "A brief description of your command",
	Long: `A longer description that spans multiple lines and likely contains examples
and usage of using your command. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
	Run: func(cmd *cobra.Command, args []string) {
		// Load AWS Config
		cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("ap-northeast-1"))
		if err != nil {
			fmt.Println("Error loading AWS config:", err)
			os.Exit(1)
		}

		// Create ECS Client
		svc := ecs.NewFromConfig(cfg)

		// Run List
		if err := ecsShell.RunList(svc); err != nil {
			fmt.Println("Error running list:", err)
			os.Exit(1)
		}
	},
}

func init() {
	rootCmd.AddCommand(listCmd)

	// Here you will define your flags and configuration settings.

	// Cobra supports Persistent Flags which will work for this command
	// and all subcommands, e.g.:
	// listCmd.PersistentFlags().String("foo", "", "A help for foo")

	// Cobra supports local flags which will only run when this command
	// is called directly, e.g.:
	// listCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}

// ecs/ecs.go
package ecs

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/service/ecs"
)

// li 1 st コマンドの実行関数
func RunList(svc *ecs.Client) error {
	// Cluster 一覧取得
	result, err := svc.ListClusters(context.TODO(), &ecs.ListClustersInput{})
	if err != nil {
		return err
	}

	for _, clusterArn := range result.ClusterArns {
		fmt.Println("Cluster:", clusterArn)

		// Service 一覧取得
		serviceResult, err := svc.ListServices(context.TODO(), &ecs.ListServicesInput{
			Cluster: &clusterArn,
		})
		if err != nil {
			return err
		}

		for _, serviceArn := range serviceResult.ServiceArns {
			fmt.Println("  Service:", serviceArn)

			// Task 一覧取得
			taskResult, err := svc.ListTasks(context.TODO(), &ecs.ListTasksInput{
				Cluster:     &clusterArn,
				ServiceName: &serviceArn,
			})
			if err != nil {
				return err
			}

			containerNames := make(map[string]struct{})

			for _, taskArn := range taskResult.TaskArns {
				// Task 詳細取得
				taskDetail, err := svc.DescribeTasks(context.TODO(), &ecs.DescribeTasksInput{
					Cluster: &clusterArn,
					Tasks:   []string{taskArn},
				})
				if err != nil {
					return err
				}

				for _, task := range taskDetail.Tasks {
					for _, container := range task.Containers {
						containerNames[*container.Name] = struct{}{}
					}
				}
			}

			fmt.Println("    Containers:")
			for containerName := range containerNames {
				fmt.Println("      -", containerName)
			}
		}
	}

	return nil
}

var clusterName, serviceName, containerName string

func init() {
	rootCmd.AddCommand(execCmd)

	execCmd.Flags().StringVarP(&clusterName, "cluster", "c", "", "cluster name")
	execCmd.Flags().StringVarP(&serviceName, "service", "s", "", "service name")
	execCmd.Flags().StringVarP(&containerName, "container", "C", "", "container name")

	execCmd.MarkFlagRequired("cluster")
	execCmd.MarkFlagRequired("service")
	execCmd.MarkFlagRequired("container")
}

Usage:
  ecs-exec-sh exec [flags]

Flags:
  -c, --cluster string     cluster name
  -C, --container string   container name
  -h, --help               help for exec
  -s, --service string     service name

go/pkg/mod/github.com/fujiwara/ecsta@v0.6.1/cp.go:54:12: pattern assets/tncl-aarch64-linux-musl: no matching files found

package ecs

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/ecs"
	"github.com/fujiwara/ecsta"
)

func ExecuteCommand(clusterName, serviceName, containerName, command string) error {
    svc, err := Client()
    if err != nil {
        return fmt.Errorf("failed to create ECS client: %w", err)
    }

    ctx := context.TODO()

    // List tasks
    listTasksOutput, err := svc.ListTasks(ctx, &ecs.ListTasksInput{
        Cluster:     aws.String(clusterName),
        ServiceName: aws.String(serviceName),
    })
    if err != nil {
        return fmt.Errorf("failed to list tasks: %w", err)
    }

    // Get task ID from the list
    taskID := listTasksOutput.TaskArns[0]

    fmt.Printf("Task: %s\n", taskID)

    ecstaApp, err := newEcsta(ctx, "ap-northeast-1", clusterName)
    if err != nil {
        return fmt.Errorf("failed to create Ecsta: %w", err)
    }

    // Execute command
    return ecstaApp.RunExec(ctx,&ecsta.ExecOption{
        ID: taskID,
        Service: &serviceName,
        Container: containerName,
        Command: command,
    })
}

func newEcsta(ctx context.Context, region, cluster string) (*ecsta.Ecsta, error) {
    app, err := ecsta.New(ctx, region, cluster)
    if err != nil {
        return nil, fmt.Errorf("failed to create Ecsta, %w", err)
    }
    return app, nil
}

parsed_globals.region:  None
client.meta.endpoint_url:  https://ecs.ap-northeast-1.amazonaws.com

func selectCluster(ctx context.Context, svc *ecs.Client) (string, error) {
	clusters, err := svc.ListClusters(ctx, &ecs.ListClustersInput{})
	if err != nil {
		return "", fmt.Errorf("failed to list clusters: %w", err)
	}

	clusterNames := make([]string, 0, len(clusters.ClusterArns))
	for _, c := range clusters.ClusterArns {
		clusterNames = append(clusterNames, extractName(c))
	}

	// selection
	sp := selection.New("Select cluster:", clusterNames)
	choice, err := sp.RunPrompt()
	if err != nil {
		return "", fmt.Errorf("failed to select cluster: %w", err)
	}
	return choice, nil
}