diff --git a/cloud-control-manager/cloud-driver/drivers/azure/AzureDriver.go b/cloud-control-manager/cloud-driver/drivers/azure/AzureDriver.go index 71038c2fc..2d0d15040 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/AzureDriver.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/AzureDriver.go @@ -110,6 +110,10 @@ func (driver *AzureDriver) ConnectCloud(connectionInfo idrv.ConnectionInfo) (ico if err != nil { return nil, err } + Ctx, sshKeyClient, err := getSshKeyClient(connectionInfo.CredentialInfo) + if err != nil { + return nil, err + } iConn := azcon.AzureCloudConnection{ CredentialInfo: connectionInfo.CredentialInfo, @@ -126,6 +130,7 @@ func (driver *AzureDriver) ConnectCloud(connectionInfo idrv.ConnectionInfo) (ico VMImageClient: VMImageClient, DiskClient: DiskClient, VmSpecClient: VmSpecClient, + SshKeyClient: sshKeyClient, } return &iConn, nil } @@ -269,6 +274,20 @@ func getSubnetClient(credential idrv.CredentialInfo) (context.Context, *network. return ctx, &subnetClient, nil } +func getSshKeyClient(credential idrv.CredentialInfo) (context.Context, *compute.SSHPublicKeysClient, error) { + config := auth.NewClientCredentialsConfig(credential.ClientId, credential.ClientSecret, credential.TenantId) + authorizer, err := config.Authorizer() + if err != nil { + return nil, nil, err + } + + sshClientClient := compute.NewSSHPublicKeysClient(credential.SubscriptionId) + sshClientClient.Authorizer = authorizer + ctx, _ := context.WithTimeout(context.Background(), cspTimeout*time.Second) + + return ctx, &sshClientClient, nil +} + func getVMImageClient(credential idrv.CredentialInfo) (context.Context, *compute.VirtualMachineImagesClient, error) { config := auth.NewClientCredentialsConfig(credential.ClientId, credential.ClientSecret, credential.TenantId) authorizer, err := config.Authorizer() @@ -310,4 +329,3 @@ func getVmSpecClient(credential idrv.CredentialInfo) (context.Context, *compute. return ctx, &vmSpecClient, nil } - diff --git a/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go b/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go index 99b6af43e..65aece113 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go @@ -43,6 +43,7 @@ type AzureCloudConnection struct { SubnetClient *network.SubnetsClient DiskClient *compute.DisksClient VmSpecClient *compute.VirtualMachineSizesClient + SshKeyClient *compute.SSHPublicKeysClient } func (cloudConn *AzureCloudConnection) CreateImageHandler() (irs.ImageHandler, error) { @@ -71,7 +72,7 @@ func (cloudConn *AzureCloudConnection) CreateSecurityHandler() (irs.SecurityHand func (cloudConn *AzureCloudConnection) CreateKeyPairHandler() (irs.KeyPairHandler, error) { cblogger.Info("Azure Cloud Driver: called CreateKeyPairHandler()!") - keypairHandler := azrs.AzureKeyPairHandler{cloudConn.CredentialInfo, cloudConn.Region} + keypairHandler := azrs.AzureKeyPairHandler{cloudConn.CredentialInfo, cloudConn.Region, cloudConn.Ctx, cloudConn.SshKeyClient} return &keypairHandler, nil } @@ -98,6 +99,7 @@ func (cloudConn *AzureCloudConnection) CreateVMHandler() (irs.VMHandler, error) NicClient: cloudConn.VNicClient, PublicIPClient: cloudConn.PublicIPClient, DiskClient: cloudConn.DiskClient, + SshKeyClient: cloudConn.SshKeyClient, } return &vmHandler, nil } diff --git a/cloud-control-manager/cloud-driver/drivers/azure/resources/CommonAzureFunc.go b/cloud-control-manager/cloud-driver/drivers/azure/resources/CommonAzureFunc.go index 3f1552958..0226f70a4 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/resources/CommonAzureFunc.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/resources/CommonAzureFunc.go @@ -1,11 +1,10 @@ package resources import ( - "crypto/md5" + "errors" "fmt" - "io" - "io/ioutil" - "os" + irs "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/interfaces/resources" + "strings" "sync" "time" @@ -21,8 +20,6 @@ const ( CBVirutalNetworkName = "CB-VNet" CBVnetDefaultCidr = "130.0.0.0/16" CBVMUser = "cb-user" - // by powerkim, 2019.10.30 - CBKeyPairPath = "/meta_db/.ssh-azure/" ) var once sync.Once @@ -90,49 +87,6 @@ func GetCallLogScheme(region idrv.RegionInfo, resourceType call.RES_TYPE, resour return &subnetCIDR, nil }*/ -// KeyPair 해시 생성 함수 -func CreateHashString(credentialInfo idrv.CredentialInfo) (string, error) { - keyString := credentialInfo.ClientId + credentialInfo.ClientSecret + credentialInfo.TenantId + credentialInfo.SubscriptionId - hasher := md5.New() - _, err := io.WriteString(hasher, keyString) - if err != nil { - return "", err - } - return fmt.Sprintf("%x", hasher.Sum(nil)), nil -} - -// Public KeyPair 정보 가져오기 -func GetPublicKey(credentialInfo idrv.CredentialInfo, keyPairName string) (string, error) { - keyPairPath := os.Getenv("CBSPIDER_ROOT") + CBKeyPairPath - hashString, err := CreateHashString(credentialInfo) - if err != nil { - return "", err - } - - publicKeyPath := keyPairPath + hashString + "--" + keyPairName + ".pub" - publicKeyBytes, err := ioutil.ReadFile(publicKeyPath) - if err != nil { - return "", err - } - return string(publicKeyBytes), nil -} - -// Private KeyPair 정보 가져오기 -/*func GetPrivateKey(credentialInfo idrv.CredentialInfo, keyPairName string) (string, error) { - keyPairPath := os.Getenv("CBSPIDER_ROOT") + CBKeyPairPath - hashString, err := CreateHashString(credentialInfo) - if err != nil { - return "", err - } - - privateKeyPath := keyPairPath + hashString + "--" + keyPairName + ".ppk" - privateKeyBytes, err := ioutil.ReadFile(privateKeyPath) - if err != nil { - return "", err - } - return string(privateKeyBytes), nil -}*/ - func GetVNicIdByName(credentialInfo idrv.CredentialInfo, regionInfo idrv.RegionInfo, vNicName string) string { return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Network/networkInterfaces/%s", credentialInfo.SubscriptionId, regionInfo.ResourceGroup, vNicName) } @@ -142,6 +96,27 @@ func GetPublicIPIdByName(credentialInfo idrv.CredentialInfo, regionInfo idrv.Reg } func GetSecGroupIdByName(credentialInfo idrv.CredentialInfo, regionInfo idrv.RegionInfo, secGroupName string) string { - // "SecurityGroupIds": ["/subscriptions/cb592624-b77b-4a8f-bb13-0e5a48cae40f/resourceGroups/CB-GROUP/providers/Microsoft.Network/networkSecurityGroups/CB-SecGroup"], return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Network/networkSecurityGroups/%s", credentialInfo.SubscriptionId, regionInfo.ResourceGroup, secGroupName) } + +func GetSshKeyIdByName(credentialInfo idrv.CredentialInfo, regionInfo idrv.RegionInfo, keyName string) string{ + return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/sshPublicKeys/%s", credentialInfo.SubscriptionId, regionInfo.ResourceGroup, keyName) +} + +func GetSshKeyNameById(sshId string) (string, error){ + slice := strings.Split(sshId, "/") + sliceLen := len(slice) + for index,item := range slice{ + if item == "sshPublicKeys" && sliceLen > index + 1 { + return slice[index + 1], nil + } + } + return "", errors.New(fmt.Sprintf("Invalid ResourceName")) +} + +func CheckIIDValidation(IId irs.IID) bool { + if IId.NameId == "" && IId.SystemId == "" { + return false + } + return true +} diff --git a/cloud-control-manager/cloud-driver/drivers/azure/resources/KeyPairHandler.go b/cloud-control-manager/cloud-driver/drivers/azure/resources/KeyPairHandler.go index 7a2da2c19..d52413203 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/resources/KeyPairHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/resources/KeyPairHandler.go @@ -1,16 +1,16 @@ package resources import ( + "context" "errors" "fmt" - "io/ioutil" - "os" - "strings" + "github.com/Azure/go-autorest/autorest/to" + "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2021-03-01/compute" + call "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/call-log" + keypair "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/common" idrv "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/interfaces" irs "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/interfaces/resources" - - keypair "github.com/cloud-barista/cb-spider/cloud-control-manager/cloud-driver/common" ) const ( @@ -20,170 +20,212 @@ const ( type AzureKeyPairHandler struct { CredentialInfo idrv.CredentialInfo Region idrv.RegionInfo + Ctx context.Context + Client *compute.SSHPublicKeysClient } -func (keyPairHandler *AzureKeyPairHandler) CheckKeyPairFolder(folderPath string) error { - // Check KeyPair Folder Exists - if _, err := os.Stat(folderPath); os.IsNotExist(err) { - if err := os.MkdirAll(folderPath, 0700); err != nil { - return err - } +func (keyPairHandler *AzureKeyPairHandler) setterKey(key compute.SSHPublicKeyResource, privateKey string) (*irs.KeyPairInfo, error) { + if key.Name == nil || key.ID == nil || key.PublicKey == nil { + return nil, errors.New(fmt.Sprintf("Invalid Key Resource")) } - return nil + keypairInfo := irs.KeyPairInfo{ + IId: irs.IID{ + NameId: *key.Name, + SystemId: *key.ID, + }, + PublicKey: *key.PublicKey, + PrivateKey: privateKey, + } + return &keypairInfo, nil } func (keyPairHandler *AzureKeyPairHandler) CreateKey(keyPairReqInfo irs.KeyPairReqInfo) (irs.KeyPairInfo, error) { - - keyPairPath := os.Getenv("CBSPIDER_ROOT") + CBKeyPairPath - if err := keyPairHandler.CheckKeyPairFolder(keyPairPath); err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err - } - hashString, err := CreateHashString(keyPairHandler.CredentialInfo) + hiscallInfo := GetCallLogScheme(keyPairHandler.Region, call.VMKEYPAIR, keyPairReqInfo.IId.NameId, "CreateKey()") + // 0. Check keyPairReqInfo + err := checkKeyPairReqInfo(keyPairReqInfo) if err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err - } - - savePrivateFileTo := keyPairPath + hashString + "--" + keyPairReqInfo.IId.NameId - savePublicFileTo := keyPairPath + hashString + "--" + keyPairReqInfo.IId.NameId + ".pub" - - // Check KeyPair Exists - if _, err := os.Stat(savePrivateFileTo); err == nil { - errMsg := fmt.Sprintf("KeyPair with name %s already exist", keyPairReqInfo.IId.NameId) - createErr := errors.New(errMsg) + createErr := errors.New(fmt.Sprintf("Failed to Create Key. err = %s", err.Error())) cblogger.Error(createErr.Error()) + LoggingError(hiscallInfo, createErr) return irs.KeyPairInfo{}, createErr } - privateKey, publicKey, err := keypair.GenKeyPair() - if err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err - } - - err = keypair.SaveKey(privateKey, savePrivateFileTo) + // 1. Check Exist + exist, err := CheckExistKey(keyPairReqInfo.IId, keyPairHandler.Region.ResourceGroup, keyPairHandler.Client, keyPairHandler.Ctx) if err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err + createErr := errors.New(fmt.Sprintf("Failed to Create Key. err = %s", err.Error())) + cblogger.Error(createErr.Error()) + LoggingError(hiscallInfo, createErr) + return irs.KeyPairInfo{}, createErr } - err = keypair.SaveKey([]byte(publicKey), savePublicFileTo) - if err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err + if exist { + createErr := errors.New(fmt.Sprintf("Failed to Create Key. err = The Key already exist")) + cblogger.Error(createErr.Error()) + LoggingError(hiscallInfo, createErr) + return irs.KeyPairInfo{}, createErr } + // 2. Create KeyPairData + privateKey, publicKey, err := keypair.GenKeyPair() - keyPairInfo := irs.KeyPairInfo{ - IId: irs.IID{ - NameId: keyPairReqInfo.IId.NameId, - SystemId: keyPairReqInfo.IId.NameId, + // 3. Set KeyPairData & keyPairReqInfo + createOpt := compute.SSHPublicKeyResource{ + Location: to.StringPtr(keyPairHandler.Region.Region), + SSHPublicKeyResourceProperties: &compute.SSHPublicKeyResourceProperties{ + PublicKey: to.StringPtr(string(publicKey)), }, - PublicKey: string(publicKey), - PrivateKey: string(privateKey), } - return keyPairInfo, nil -} -func (keyPairHandler *AzureKeyPairHandler) ListKey() ([]*irs.KeyPairInfo, error) { - - keyPairPath := os.Getenv("CBSPIDER_ROOT") + CBKeyPairPath - if err := keyPairHandler.CheckKeyPairFolder(keyPairPath); err != nil { - cblogger.Error(err) - return nil, err + start := call.Start() + // 4. Create KeyPair(Azure SSH Resource) + keyResult, err := keyPairHandler.Client.Create(keyPairHandler.Ctx, keyPairHandler.Region.ResourceGroup, keyPairReqInfo.IId.NameId, createOpt) + if err != nil { + createErr := errors.New(fmt.Sprintf("Failed to Create Key. err = %s", err.Error())) + cblogger.Error(createErr.Error()) + LoggingError(hiscallInfo, createErr) + return irs.KeyPairInfo{}, createErr } - hashString, err := CreateHashString(keyPairHandler.CredentialInfo) + // 5. Set keyPairInfo + keyPairInfo, err := keyPairHandler.setterKey(keyResult, string(privateKey)) if err != nil { - cblogger.Error(err) - return nil, err + createErr := errors.New(fmt.Sprintf("Failed to Create Key. err = %s", err.Error())) + cblogger.Error(createErr.Error()) + LoggingError(hiscallInfo, createErr) + return irs.KeyPairInfo{}, createErr } + LoggingInfo(hiscallInfo, start) + return *keyPairInfo, nil +} - var keyPairInfoList []*irs.KeyPairInfo +func (keyPairHandler *AzureKeyPairHandler) ListKey() ([]*irs.KeyPairInfo, error) { + hiscallInfo := GetCallLogScheme(keyPairHandler.Region, call.VMKEYPAIR, KeyPair, "ListKey()") + start := call.Start() - files, err := ioutil.ReadDir(keyPairPath) + // 0. Get List Resource + listResult, err := keyPairHandler.Client.ListByResourceGroup(keyPairHandler.Ctx, keyPairHandler.Region.ResourceGroup) if err != nil { - cblogger.Error(err) - return nil, err - } - - for _, f := range files { - if strings.Contains(f.Name(), ".pub") { - continue - } - if strings.Contains(f.Name(), hashString) { - fileNameArr := strings.Split(f.Name(), "--") - keypairInfo, err := keyPairHandler.GetKey(irs.IID{NameId: fileNameArr[1]}) - if err != nil { - return nil, err - } - keyPairInfoList = append(keyPairInfoList, &keypairInfo) + getErr := errors.New(fmt.Sprintf("Failed to Get KeyList. err = %s", err.Error())) + cblogger.Error(getErr.Error()) + LoggingError(hiscallInfo, getErr) + return nil, getErr + } + // 0. Set List Resource + var keyInfoList []*irs.KeyPairInfo + for _, key := range listResult.Values() { + keyInfo, err := keyPairHandler.setterKey(key, "") + if err != nil { + getErr := errors.New(fmt.Sprintf("Failed to Get KeyList. err = %s", err.Error())) + cblogger.Error(getErr.Error()) + LoggingError(hiscallInfo, getErr) + return nil, getErr } + keyInfoList = append(keyInfoList, keyInfo) } - return keyPairInfoList, nil + LoggingInfo(hiscallInfo, start) + + return keyInfoList, nil } func (keyPairHandler *AzureKeyPairHandler) GetKey(keyIID irs.IID) (irs.KeyPairInfo, error) { - - keyPairPath := os.Getenv("CBSPIDER_ROOT") + CBKeyPairPath - if err := keyPairHandler.CheckKeyPairFolder(keyPairPath); err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err - } - hashString, err := CreateHashString(keyPairHandler.CredentialInfo) - - privateKeyPath := keyPairPath + hashString + "--" + keyIID.NameId - publicKeyPath := keyPairPath + hashString + "--" + keyIID.NameId + ".pub" - - // Private Key, Public Key 파일 정보 가져오기 - privateKeyBytes, err := ioutil.ReadFile(privateKeyPath) + hiscallInfo := GetCallLogScheme(keyPairHandler.Region, call.VMKEYPAIR, keyIID.NameId, "GetKey()") + start := call.Start() + // 0. Check keyPairInfo + if iidCheck := CheckIIDValidation(keyIID); !iidCheck { + getErr := errors.New(fmt.Sprintf("Failed to Get Key. err = InValid IID")) + cblogger.Error(getErr.Error()) + LoggingError(hiscallInfo, getErr) + return irs.KeyPairInfo{}, getErr + } + // 1. Get Resource + key, err := GetRawKey(keyIID, keyPairHandler.Region.ResourceGroup, keyPairHandler.Client, keyPairHandler.Ctx) if err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err + getErr := errors.New(fmt.Sprintf("Failed to Get Key. err = %s", err.Error())) + cblogger.Error(getErr.Error()) + LoggingError(hiscallInfo, getErr) + return irs.KeyPairInfo{}, getErr } - publicKeyBytes, err := ioutil.ReadFile(publicKeyPath) + // 2. Set Resource + keyPairInfo, err := keyPairHandler.setterKey(key, "") if err != nil { - cblogger.Error(err) - return irs.KeyPairInfo{}, err + getErr := errors.New(fmt.Sprintf("Failed to Get Key. err = %s", err.Error())) + cblogger.Error(getErr.Error()) + LoggingError(hiscallInfo, getErr) + return irs.KeyPairInfo{}, getErr } - - keypairInfo := irs.KeyPairInfo{ - IId: irs.IID{ - NameId: keyIID.NameId, - SystemId: keyIID.NameId, - }, - PublicKey: string(publicKeyBytes), - PrivateKey: string(privateKeyBytes), - } - return keypairInfo, nil + LoggingInfo(hiscallInfo, start) + return *keyPairInfo, nil } func (keyPairHandler *AzureKeyPairHandler) DeleteKey(keyIID irs.IID) (bool, error) { - - keyPairPath := os.Getenv("CBSPIDER_ROOT") + CBKeyPairPath - if err := keyPairHandler.CheckKeyPairFolder(keyPairPath); err != nil { - return false, err - } - hashString, err := CreateHashString(keyPairHandler.CredentialInfo) + hiscallInfo := GetCallLogScheme(keyPairHandler.Region, call.VMKEYPAIR, keyIID.NameId, "DeleteKey()") + // 0. Check keyPairInfo + if iidCheck := CheckIIDValidation(keyIID); !iidCheck { + delErr := errors.New(fmt.Sprintf("Failed to Delete Key err = InValid IID")) + cblogger.Error(delErr.Error()) + LoggingError(hiscallInfo, delErr) + return false, delErr + } + // 1. Check Exist + exist, err := CheckExistKey(keyIID, keyPairHandler.Region.ResourceGroup, keyPairHandler.Client, keyPairHandler.Ctx) if err != nil { - cblogger.Error(err) - return false, err + delErr := errors.New(fmt.Sprintf("Failed to Delete Key. err = %s", err.Error())) + cblogger.Error(delErr.Error()) + LoggingError(hiscallInfo, delErr) + return false, delErr + } + + if !exist { + delErr := errors.New(fmt.Sprintf("Failed to Delete Key. err = The Key not exist")) + cblogger.Error(delErr.Error()) + LoggingError(hiscallInfo, delErr) + return false, delErr } - privateKeyPath := keyPairPath + hashString + "--" + keyIID.NameId - publicKeyPath := keyPairPath + hashString + "--" + keyIID.NameId + ".pub" + start := call.Start() + // 2. Delete Resource + _, err = keyPairHandler.Client.Delete(keyPairHandler.Ctx, keyPairHandler.Region.ResourceGroup, keyIID.NameId) - // Private Key, Public Key 삭제 - err = os.Remove(privateKeyPath) if err != nil { - cblogger.Error(err) - return false, err + delErr := errors.New(fmt.Sprintf("Failed to Delete Key. err = %s", err.Error())) + cblogger.Error(delErr.Error()) + LoggingError(hiscallInfo, delErr) + return false, delErr } - err = os.Remove(publicKeyPath) + LoggingInfo(hiscallInfo, start) + return true, nil +} +func CheckExistKey(keypairIId irs.IID, resourceGroup string, client *compute.SSHPublicKeysClient, ctx context.Context) (bool, error) { + keyList, err := client.ListByResourceGroup(ctx, resourceGroup) if err != nil { - cblogger.Error(err) return false, err } + for _, keyValue := range keyList.Values() { + if keypairIId.SystemId != "" && keypairIId.SystemId == *keyValue.ID { + return true, nil + } + if keypairIId.NameId != "" && keypairIId.NameId == *keyValue.Name { + return true, nil + } + } + return false, nil +} - return true, nil +func GetRawKey(keypairIId irs.IID, resourceGroup string, client *compute.SSHPublicKeysClient, ctx context.Context) (compute.SSHPublicKeyResource, error) { + if keypairIId.NameId == "" { + convertedNameId, err := GetSshKeyNameById(keypairIId.SystemId) + if err != nil { + return compute.SSHPublicKeyResource{}, err + } + return client.Get(ctx, resourceGroup, convertedNameId) + } else { + return client.Get(ctx, resourceGroup, keypairIId.NameId) + } +} + +func checkKeyPairReqInfo(keyPairReqInfo irs.KeyPairReqInfo) error { + if keyPairReqInfo.IId.NameId == "" { + return errors.New("invalid Key IID") + } + return nil } diff --git a/cloud-control-manager/cloud-driver/drivers/azure/resources/VMHandler.go b/cloud-control-manager/cloud-driver/drivers/azure/resources/VMHandler.go index 8deddaa21..3b960da9d 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/resources/VMHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/resources/VMHandler.go @@ -40,6 +40,7 @@ type AzureVMHandler struct { NicClient *network.InterfacesClient PublicIPClient *network.PublicIPAddressesClient DiskClient *compute.DisksClient + SshKeyClient *compute.SSHPublicKeysClient } func (vmHandler *AzureVMHandler) StartVM(vmReqInfo irs.VMReqInfo) (irs.VMInfo, error) { @@ -128,12 +129,13 @@ func (vmHandler *AzureVMHandler) StartVM(vmReqInfo irs.VMReqInfo) (irs.VMInfo, e // KeyPair 설정 if vmReqInfo.KeyPairIID.NameId != "" { - publicKey, err := GetPublicKey(vmHandler.CredentialInfo, vmReqInfo.KeyPairIID.NameId) + key, err := GetRawKey(vmReqInfo.KeyPairIID, vmHandler.Region.ResourceGroup, vmHandler.SshKeyClient, vmHandler.Ctx) if err != nil { cblogger.Error(err.Error()) LoggingError(hiscallInfo, err) return irs.VMInfo{}, err } + publicKey := *key.PublicKey vmOpts.OsProfile.LinuxConfiguration = &compute.LinuxConfiguration{ SSH: &compute.SSHConfiguration{ PublicKeys: &[]compute.SSHPublicKey{ @@ -144,14 +146,13 @@ func (vmHandler *AzureVMHandler) StartVM(vmReqInfo irs.VMReqInfo) (irs.VMInfo, e }, }, } + vmOpts.Tags = map[string]*string{ + "keypair": to.StringPtr(vmReqInfo.KeyPairIID.NameId), + "publicip": to.StringPtr(publicIPIId.NameId), + } } else { vmOpts.OsProfile.AdminPassword = to.StringPtr(vmReqInfo.VMUserPasswd) - } - - // VM 정보 태깅 설정 - if vmReqInfo.KeyPairIID.NameId != "" { vmOpts.Tags = map[string]*string{ - "keypair": to.StringPtr(vmReqInfo.KeyPairIID.NameId), "publicip": to.StringPtr(publicIPIId.NameId), } } @@ -583,10 +584,10 @@ func (vmHandler *AzureVMHandler) mappingServerInfo(server compute.VirtualMachine // Get Keypair tagList := server.Tags for key, val := range tagList { - if key == "keypair" { - vmInfo.KeyPairIId = irs.IID{NameId: *val, SystemId: *val} + if key == "keypair" && val != nil { + vmInfo.KeyPairIId = irs.IID{NameId: *val, SystemId: GetSshKeyIdByName(vmHandler.CredentialInfo, vmHandler.Region, *val)} } - if key == "publicip" { + if key == "publicip" && val != nil { vmInfo.KeyValueList = []irs.KeyValue{ {Key: "publicip", Value: *val}, }