This is because you have an Apple Silicon CPU and the server that will run your image is based on a more traditional amd64/x86_64 architecture. For this, you will need to create an image that supports that type of CPU.

To achieve this, in docker you have the command buildx build wich allows you to create images for different architectures, even to make it compatible with multiple architectures.

The use of this command is very simple. Returning to our initial scenario. If you are a Mac user with Apple Silicon CPU, just run:

docker buildx build --platform linux/amd64 -t myimage:tag .

Where linux/amd64 is the destination architecture for your image.

That's it, it was very simple, right? if you want to learn more about this command, here is the official documentation.

Did you know about this command before?

Share in the comments if it was useful to you.

Thanks for reading.

The thing is, that there is not a standard way to make it easily, at least not without any third-party library. So, making some research I found this blog post.

The author explains really well how to build a multipart request through a self-written struct called MultipartRequest.

But in my case, it didn't work out of the box, I'm pretty sure it was because I'm using a newer version of Swift.

So, in order to make it work, I made a few changes.

Creating the MultipartRequest struct

The principal change I made was to replace the type of the data property from Data to NSMutableData.

private var data: NSMutableData

This is because the compiler marked an error telling me that Data was not mutable.

Then I had to add an extension to NSMutableData instead to Data.

extension NSMutableData {
    func appendString(_ string: String) {
        if let data = string.data(using: .utf8) {
            self.append(data)
        }
    }
}

And finally modified the calculated property httpBody to cast the NSMutableData to Data.

public var httpBody: Data {
    data.appendString("--\(boundary)--")
    return data as Data
}

Here you can see the full struct:

import Foundation

public struct MultipartRequest {

    public let boundary: String

    private let separator: String = "\r\n"
    private var data: NSMutableData

    public init(boundary: String = UUID().uuidString) {
        self.boundary = boundary
        self.data = .init()
    }

    private mutating func appendBoundarySeparator() {
        data.appendString("--\(boundary)\(separator)")
    }

    private mutating func appendSeparator() {
        data.appendString(separator)
    }

    private func disposition(_ key: String) -> String {
        "Content-Disposition: form-data; name=\"\(key)\""
    }

    public mutating func add(
        key: String,
        value: String
    ) {
        appendBoundarySeparator()
        data.appendString(disposition(key) + separator)
        appendSeparator()
        data.appendString(value + separator)
    }

    public mutating func add(
        key: String,
        fileName: String,
        fileMimeType: String,
        fileData: Data
    ) {
        appendBoundarySeparator()
        data.appendString(disposition(key) + "; filename=\"\(fileName)\"" + separator)
        data.appendString("Content-Type: \(fileMimeType)" + separator + separator)
        data.append(fileData)
        appendSeparator()
    }

    public var httpContentTypeHeadeValue: String {
        "multipart/form-data; boundary=\(boundary)"
    }

    public var httpBody: Data {
        data.appendString("--\(boundary)--")
        return data as Data
    }
}

extension NSMutableData {
    func appendString(_ string: String) {
        if let data = string.data(using: .utf8) {
            self.append(data)
        }
    }
}

Using the MultipartRequest struct.

Using this struct is very easy:

First, instantiate an object of the MultipartRequest struct.

var multipart = MultipartRequest()

Now you can add parameters to your request:

multipart.add(key: "name", value: "John")

And of course, you can add your file data (in this example it's an image):

multipart.add(
    key: "file",
    fileName: "test.png",
    fileMimeType: "image/png",
    fileData: imageData
)

Build your request.

let url = URL(string: "https://myurl")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
// Here is how to use your struct to set your content-type header
request.setValue(multipart.httpContentTypeHeadeValue, forHTTPHeaderField: "Content-Type")
// set the body request
request.httpBody = multipart.httpBody

Finally, execute the request.

do {
  let (responseData, response) = try await  URLSession.shared.data(for: request)
  print((response as! HTTPURLResponse).statusCode)
  print(String(data: responseData, encoding: .utf8)!)
} catch {
  print ("Error")
}

Now you can upload files from your iOS app.

Conclusion.

I created this Github repository as an example using an image picker on SwiftUI.

Share in the comments if it is useful or if you know another way to do it.

Thanks for reading.

Most examples on tutorials, use a public image from docker hub to show you how to create a deployment, but when you work in a company that has a private registry, you will need a way to be authenticated.

And that way is to use a secret.

In this post, I’m going to explain how to do it using the registries given by GitHub and GitLab.

Creating an authentication token.

The first step would be to create an authentication token to get access to your registry.

Github.

For Github go to Account Settings → Developer Settings → Personal access tokens and click on Generate new token.

Create a new token (you can set it to expire or not depending on your needs).

Check read_packages.

Copy the generated token. We will use it later on our secret.

GitLab.

For GitLab go to User Settings → Access Tokens and create a token giving it a name and check on read_registry.

Copy the generated token. We will use it later on our secret.

Create the secret.

Now use kubectl to create your secret:

kubectl create secret docker-registry [SECRET_NAME] \
 --docker-server=[SERVICE_REGISTRY] \ 
 --docker-username=[USERNAME] \
 --docker-password=[TOKEN] \
 --docker-email=[EMAIL]

Where:

• [SECRET_NAME] is the name of your secret and you will use it later in the deployment, for example; mysecret.

• [SERVICE_REGISTRY] is your registry domain.

  • For GitHub: ghcr.io

  • For GitLab: registry.gitlab.com

For example:

kubectl create secret docker-registry mysecret \
 --docker-server=ghcr.io \ 
 --docker-username=myusername \
 --docker-password=[TOKEN] \
 --docker-email=myusername@mail.com

Configure your deployment.

Now you can add the section imagePullSecrets in your deployment.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mydeployment
spec:
  ...
    spec:
      imagePullSecrets:
        - name: mysecret
      containers:
        - image: ghcr.io/myusername/myproject:latest
    ...

Pay special attention to:

imagePullSecrets:
        - name: mysecret

And that’s it, your deployment will be authenticated and download your container’s image to create your pods.

Please let me a comment and tell me if this was useful for you.

Thank you.