import * as awsx from "@pulumi/awsx";                                              
import { project, baseTags } from '../config';                                     

const vpc = awsx.ec2.Vpc.getDefault();                                             

const alb = new awsx.lb.ApplicationLoadBalancer(`${project}-lb`, {                 
  vpc,                                                                             
  tags: baseTags,                                                                  
  external: true,                                                                                                                                               
});                                                                                

export const http = alb.createListener(`${project}-http`, {                                                              
  defaultActions: [{                                                               
    fixedResponse: {                                                               
      contentType: "text/plain",                                                   
      messageBody: "404 Site Not Found",                                           
      statusCode: "404",                                                           
    },                                                                             
    type: "fixed-response",                                                        
  }],                                        
  external: true,                                                               
  port: 80,                                                                     
  protocol: "HTTP",                                                             
});                                                                             

export const nginxTarget = alb.createTargetGroup(`${project}-nginx-tg`, {       
  port: 80,                                                                     
  protocol: "HTTP",                                                             
  tags: baseTags,                                                               
});                                                                             

export const helloTarget = alb.createTargetGroup(`${project}-hello-tg`, {       
  port: 80,                                                                     
  protocol: "HTTP",                                                             
  tags: baseTags,                                                               
});                                                                             

const nginxRule = http.addListenerRule(`${project}-nginx-lr`, {                 
  actions: [{                                                                   
    targetGroupArn: nginxTarget.targetGroup.arn.apply(v => v),                  
    type: "forward",                                                            
  }],                                                                           
  conditions: [{                                                                
    pathPattern: {                                                              
      values: ["/nginx"],                                                       
    }},{                                                                          
    hostHeader: {                                                               
      values: [`*`],                                                            
    },                                                                          
  }],                                                                           
  priority: 1,                                                                  
});                                                                             

const helloRule = http.addListenerRule(`${project}-hello-lr`, {                 
  actions: [{                                                                   
    targetGroupArn: helloTarget.targetGroup.arn.apply(v => v),                  
    type: "forward",                                                            
  }],                                                                           
  conditions: [{                                                                
    pathPattern: {                                                              
      values: ["/hello"],                                                       
    }},{                                                                          
    hostHeader: {                                                               
      values: [`*`],                                                            
    },                                                                          
  }],                                                                           
  priority: 1,                                                                  
});                                                                             

const cluster = new awsx.ecs.Cluster("cluster", {                                  
  vpc,                                                                             
  tags: baseTags,                                                                  
});                                                                                

const nginxService = new awsx.ecs.FargateService("backend-nginx", {                
    cluster,                                                                       
    taskDefinitionArgs: {                                                          
        containers: {                                                              
            nginx: {                                                               
                image: "nginx",                                                    
                cpu: 128,                                                          
                memory: 128,                                                       
                portMappings: [ nginxTarget ],                                     
            },                                                                     
        },                                                                         
    },                                                                             
    desiredCount: 3,                                                               
});                                                                                

const img = awsx.ecs.Image.fromPath("hello-img", "./app");                         

const helloService = new awsx.ecs.FargateService("backend-hello", {                
    cluster,                                                                       
    taskDefinitionArgs: {                                                          
        container: {                                                               
            image: img,                                                            
            cpu: 128,                                                              
            memory: 128,                                                           
            portMappings: [ helloTarget ],                                         
        },                                                                         
    },                                                                             
    desiredCount: 5,                                                               
});

listeners

ApplicationTargetGroup

[]