解组AWS IAM文档但条件字符串或文档中的字符串

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《解组AWS IAM文档但条件字符串或文档中的字符串》，涉及到，有需要的可以收藏一下

我正在研究 aws go sdk 的 iam 策略示例，并尝试执行与 create policy 示例相反的操作 - 基本上，获取账户中的所有 iam 策略，获取默认策略版本，然后解组将该 json 文档转换为结构，以便轻松解析。

我已经走到这一步了，但我仍然不知道 go 如何处理条件结构类型。在 aws 策略文档版本响应中，statemententry 的 json 数据可以是 string 或 []string，具体取决于文档。

最佳实践是什么？添加另一个结构并在错误处理中使用重试逻辑？

package main

import (
    "encoding/json"
    "fmt"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/iam"
    "log"
    "net/url"
)

type policydocument struct {
    version   string
    statement []statemententry
}

type statemententry struct {
    effect   string
    action   []string
    resource []string
}

func main() {
    sess, _ := session.newsession(&aws.config{
        region: aws.string("us-west-2")},
    )

    svc := iam.new(sess)

    fmt.printf("%s - %s\n", arn, *result.policy.description)

    results, _ := svc.listpolicies(&iam.listpoliciesinput{})

    for _, policy := range results.policies {

        arn := policy.arn
        version := policy.defaultversionid

        pv, _ := svc.getpolicyversion(&iam.getpolicyversioninput{
            policyarn: arn,
            versionid: version,
        })

        decodedvalue, err := url.queryunescape(aws.stringvalue(pv.policyversion.document))
        if err != nil {
            log.fatal(err)
            return
        }
        //fmt.println(decodedvalue)

        data := []byte(decodedvalue)

        var doc policydocument
        err1 := json.unmarshal(data, &doc)

        if err1 != nil {
            log.fatal(err1)
        }

        fmt.printf("\n----\n%v\n---\n", doc)
    }
}

示例 policydocuments 是这样的：

{
    "version": "2012-10-17",
    "statement": [
        {
            "sid": "visualeditor0",
            "effect": "allow",
            "action": [
                "ssm:putparameter",
                "ssm:deleteparameter",
                "ssm:describeinstancepatchstates",
                "elasticloadbalancing:registertargets",
                "elasticloadbalancing:describetargethealth",
                "elasticloadbalancing:describetargetgroups",
                "elasticloadbalancing:deregistertargets",
                "ssm:getparameter"
            ],
            "resource": "*"
        }
    ]
}

这个（对于 statemententry 中的 resource []string）：

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "s3:ListBucket"
            ],
            "Effect": "Allow",
            "Resource": [
                "arn:aws:s3:::SageMaker"
            ]
        },
        {
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject"
            ],
            "Effect": "Allow",
            "Resource": [
                "arn:aws:s3:::SageMaker/*"
            ]
        }
    ]
}

解决方案

您可以通过使用切片的自定义类型和 unmarshal 方法来实现此目的，该方法首先解组到空接口，然后确定它是切片还是单个字符串：

package main

import (
    "fmt"
    "encoding/json"
    "errors"
)

type container struct {
    field customslice
}

type customslice []string

func (c *customslice) unmarshaljson(data []byte) error {
    var tmp interface{}
    err := json.unmarshal(data, &tmp)
    if err != nil {
        return err
    }
    slice, ok := tmp.([]interface{})
    if ok {
        for _, item := range slice {
            *c = append(*c, item.(string))
        }
        return nil
    }
    thestring, ok := tmp.(string)
    if ok {
        *c = append(*c, thestring)
        return nil
    }
    return errors.new("field neither slice or string")
}

func main() {
    jsoninputslice := `{"field":["a"]}`
    jsoninputstring := `{"field":"a"}`
    var containerslice container
    var containerstring container
    err := json.unmarshal([]byte(jsoninputslice), &containerslice)
    if err != nil {
        panic(err)
    }
    fmt.println(containerslice)
    err = json.unmarshal([]byte(jsoninputstring), &containerstring)
    if err != nil {
        panic(err)
    }
    fmt.println(containerstring)

}

https://play.golang.org/p/mAhJBNhE1yc

您可以通过多种方式执行此操作。一种方法是将 resource 定义为 interface{} 并稍后进行解析。演示 - https://play.golang.org/p/PiLaa0DySEj

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

type PolicyDocument struct {
    Version   string
    Statement []StatementEntry
}

type StatementEntry struct {
    Effect   string
    Action   []string
    Resource interface{}
}

func main() {

    data := `{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "ssm:PutParameter",
                "ssm:DeleteParameter",
                "ssm:DescribeInstancePatchStates",
                "elasticloadbalancing:RegisterTargets",
                "elasticloadbalancing:DescribeTargetHealth",
                "elasticloadbalancing:DescribeTargetGroups",
                "elasticloadbalancing:DeregisterTargets",
                "ssm:GetParameter"
            ],
            "Resource": "*"
        }
    ]
}`

    convertPolicy(data)

    data = `{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "s3:ListBucket"
            ],
            "Effect": "Allow",
            "Resource": [
                "arn:aws:s3:::SageMaker"
            ]
        },
        {
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject"
            ],
            "Effect": "Allow",
            "Resource": [
                "arn:aws:s3:::SageMaker/*"
            ]
        }
    ]
}`

    convertPolicy(data)

}

func convertPolicy(data string) {
    var doc PolicyDocument
    err1 := json.Unmarshal([]byte(data), &doc)

    if err1 != nil {
        fmt.Println(err1)
    }

    //find out the type of resource string or []string
    for _, statement := range doc.Statement {
        fmt.Println("statement.Resource was of type - ", reflect.TypeOf(statement.Resource))
        if reflect.TypeOf(statement.Resource).Name() != "string" {
            // we will convert the []interface to []string
            x := statement.Resource.([]interface{})
            y := make([]string, len(x))
            for i := 0; i < len(x); i++ {
                y[i] = x[i].(string)
            }
            statement.Resource = y
            fmt.Println("statement.Resource is converted to type - ", reflect.TypeOf(statement.Resource))
        }
    }

    fmt.Printf("\n----\n%v\n---\n", doc)
}

今天关于《解组AWS IAM文档但条件字符串或文档中的字符串》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！