135 lines
3.6 KiB
Go
135 lines
3.6 KiB
Go
package amazon
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/docker/ecs-plugin/pkg/compose"
|
|
"github.com/sirupsen/logrus"
|
|
"strings"
|
|
|
|
"github.com/aws/aws-sdk-go/aws"
|
|
"github.com/aws/aws-sdk-go/service/elbv2"
|
|
"github.com/compose-spec/compose-go/types"
|
|
)
|
|
|
|
func (c client) CreateLoadBalancer(project *compose.Project, subnets []*string) (*string, error) {
|
|
logrus.Debug("Create Load Balancer")
|
|
alb, err := c.ELB.CreateLoadBalancer(&elbv2.CreateLoadBalancerInput{
|
|
IpAddressType: nil,
|
|
Name: aws.String(fmt.Sprintf("%s-LoadBalancer", project.Name)),
|
|
Subnets: subnets,
|
|
Type: aws.String(elbv2.LoadBalancerTypeEnumNetwork),
|
|
Tags: []*elbv2.Tag{
|
|
{
|
|
Key: aws.String("com.docker.compose.project"),
|
|
Value: aws.String(project.Name),
|
|
},
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return alb.LoadBalancers[0].LoadBalancerArn, nil
|
|
}
|
|
|
|
func (c client) DeleteLoadBalancer(project *compose.Project, keepLoadBalancer bool) error {
|
|
logrus.Debug("Delete Load Balancer")
|
|
// FIXME We can tag LoadBalancer but not search by tag ?
|
|
loadBalancer, err := c.ELB.DescribeLoadBalancers(&elbv2.DescribeLoadBalancersInput{
|
|
Names: aws.StringSlice([]string{fmt.Sprintf("%s-LoadBalancer", project.Name)}),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
arn := loadBalancer.LoadBalancers[0].LoadBalancerArn
|
|
|
|
err = c.DeleteListeners(arn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = c.DeleteTargetGroups(arn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !keepLoadBalancer {
|
|
_, err = c.ELB.DeleteLoadBalancer(&elbv2.DeleteLoadBalancerInput{LoadBalancerArn: arn})
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (c client) CreateTargetGroup(name string, vpc *string, port types.ServicePortConfig) (*string, error) {
|
|
logrus.Debugf("Create Target Group %d/%s\n", port.Target, port.Protocol)
|
|
group, err := c.ELB.CreateTargetGroup(&elbv2.CreateTargetGroupInput{
|
|
Name: aws.String(name),
|
|
Port: aws.Int64(int64(port.Target)),
|
|
Protocol: aws.String(strings.ToUpper(port.Protocol)),
|
|
TargetType: aws.String("ip"),
|
|
VpcId: vpc,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
arn := group.TargetGroups[0].TargetGroupArn
|
|
return arn, nil
|
|
}
|
|
|
|
func (c client) DeleteTargetGroups(loadBalancer *string) error {
|
|
groups, err := c.ELB.DescribeTargetGroups(&elbv2.DescribeTargetGroupsInput{
|
|
LoadBalancerArn: loadBalancer,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, group := range groups.TargetGroups {
|
|
logrus.Debugf("Delete Target Group %s\n", *group.TargetGroupArn)
|
|
_, err := c.ELB.DeleteTargetGroup(&elbv2.DeleteTargetGroupInput{
|
|
TargetGroupArn: group.TargetGroupArn,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c client) CreateListener(port types.ServicePortConfig, arn *string, target *string) error {
|
|
logrus.Debugf("Create Listener %d\n", port.Published)
|
|
_, err := c.ELB.CreateListener(&elbv2.CreateListenerInput{
|
|
DefaultActions: []*elbv2.Action{
|
|
{
|
|
ForwardConfig: &elbv2.ForwardActionConfig{
|
|
TargetGroups: []*elbv2.TargetGroupTuple{
|
|
{
|
|
TargetGroupArn: target,
|
|
},
|
|
},
|
|
},
|
|
Type: aws.String(elbv2.ActionTypeEnumForward),
|
|
},
|
|
},
|
|
LoadBalancerArn: arn,
|
|
Port: aws.Int64(int64(port.Published)),
|
|
Protocol: aws.String(strings.ToUpper(port.Protocol)),
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (c client) DeleteListeners(loadBalancer *string) error {
|
|
listeners, err := c.ELB.DescribeListeners(&elbv2.DescribeListenersInput{
|
|
LoadBalancerArn: loadBalancer,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, listener := range listeners.Listeners {
|
|
logrus.Debugf("Delete Listener %s\n", *listener.ListenerArn)
|
|
_, err := c.ELB.DeleteListener(&elbv2.DeleteListenerInput{
|
|
ListenerArn: listener.ListenerArn,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
} |